第二篇: Go常用包

1.打印信息print各个区别

1. Println 打印的每一项之间都会有回车空行，Print 没有
2. Printf是格式化输出
func main() {
    a:=10
    b:=20
    c:=30
    fmt.Println("a=", a , ",b=" , b , ",c=" , c) # a= 10 ,b= 20 ,c= 30
    fmt.Printf("a=%d,b=%d,c=%d" , a , b , c) # a=10,b=20,c=30
}
不加fmt，转成ascill码

格式说明

| 格式 | 含义 |

| | %% | 一个%字面量 | |
| | %b | 一个二进制整数值(基数为2)，或者是一个(高级的)用科学计数法表示的指数为2的浮点数 | |
| | %c | 字符型。可以把输入的数字按照ASCII码相应转换为对应的字符 | |
| | %d | 一个十进制数值(基数为10) | |
| | %e | 以科学记数法e表示的浮点数或者复数值 | |
| | %E | 以科学记数法E表示的浮点数或者复数值 | |
| | %f | 以标准记数法表示的浮点数或者复数值 | |
| | %g | 以%e或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出 | |
| | %G | 以%E或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出 | |
| | %o | 一个以八进制表示的数字(基数为8) | |
| | %p | 以十六进制(基数为16)表示的一个值的地址，前缀为0x,字母使用小写的a-f表示 | |
| | %q | 使用Go语法以及必须时使用转义，以双引号括起来的字符串或者字节切片[]byte，或者是以单引号括起来的数字 | |
| | %s | 字符串。输出字符串中的字符直至字符串中的空字符（字符串以'\0‘结尾，这个'\0'即空字符） | |
| | %t | 以true或者false输出的布尔值 | |
| | %T | 使用Go语法输出的值的类型 | |
| | %U | 一个用Unicode表示法表示的整型码点，默认值为4个数字字符 | |
| | %v | 使用默认格式输出的内置或者自定义类型的值，或者是使用其类型的String()方式输出的自定义值，如果该方法存在的话 | |
| | %x | 以十六进制表示的整型值(基数为十六)，数字a-f使用小写表示 | |
| | %X | 以十六进制表示的整型值(基数为十六)，数字A-F使用小写表示 | |

输人Scanf类似input

    var v int
    fmt.Println("请输入一个整型：")
    fmt.Scanf("%d", &v)
    //fmt.Scan(&v)
    fmt.Println("v = ", v)

fmt.Sprintf格式化输出

func main() {
	name := "jeff"
	a := fmt.Sprintf("我的名字是%s", name)
	fmt.Println(a) // 我的名字是jeff
}

2.查看类型-TypeOf,%T

num := 10
reflect.TypeOf(num)  // int
fmt.Printf("type = %T", num) //type = int

3.查看长度-len

a := []int{1, 2, 3, 4, 
fmt.Println(len(a))  //5
           
           
数组：v中的元素数。
指向数组的指针：* v中的元素数（即使v为零）。
切片或map：v中的元素数量； 如果v为零，则len（v）为零。
字符串：v中的字节数。
Channel：在通道缓冲区中排队（未读）的元素数；
如果v为零，则len（v）为零。

4.类型转换strconv包

string到int

int,err := strconv.Atoi(string)  

string到int64

int64, err := strconv.ParseInt(string, 10, 64)
//第二个参数为基数（2~36），
//第三个参数位大小表示期望转换的结果类型，其值可以为0, 8, 16, 32和64，
//分别对应 int, int8, int16, int32和int64

int到string

string := strconv.Itoa(int) 
//等价于
string := strconv.FormatInt(int64(int),10)

int64到string

string := strconv.FormatInt(int64,10)  
//第二个参数为基数，可选2~36
//对于无符号整形，可以使用FormatUint(i uint64, base int)

float到string

string := strconv.FormatFloat(float32,'E',-1,32)
string := strconv.FormatFloat(float64,'E',-1,64)
// 'b' (-ddddp±ddd，二进制指数)
// 'e' (-d.dddde±dd，十进制指数)
// 'E' (-d.ddddE±dd，十进制指数)
// 'f' (-ddd.dddd，没有指数)
// 'g' ('e':大指数，'f':其它情况)
// 'G' ('E':大指数，'f':其它情况)

string到float64

float,err := strconv.ParseFloat(string,64)

string到float32

float,err := strconv.ParseFloat(string,32)

int到int64

int64_ := int64(1234)

5.十进制任意相互转换

package main

import (
	"fmt"
	"math"
	"strings"
)

var chars string = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

// 10进制转任意进制
func encode(num int64) string {
	var j int64
	j = 62 // 目标进制62进制
	bytes := []byte{}
	for num > 0 {
		bytes = append(bytes, chars[num%j])
		num = num / j
	}
	reverse(bytes)
	return string(bytes)
}

// 任意进制转10进制
func decode(str string) int64 {
	var num int64
	var j float64
	j = 62  // str的进制是62进制
	n := len(str)
	for i := 0; i < n; i++ {
		pos := strings.IndexByte(chars, str[i])
		num += int64(math.Pow(j, float64(n-i-1)) * float64(pos))
	}
	return num
}

func reverse(a []byte) {
	for left, right := 0, len(a)-1; left < right; left, right = left+1, right-1 {
		a[left], a[right] = a[right], a[left]
	}
}

func main() {
	a:=encode(3929151817)
	fmt.Println(a) // 4hUjSp
	b:=decode("4hUjSp")
	fmt.Println(b) // 3929151817
}

6.查看容量-cap

li := []int{1, 2, 3, 4, 5}
fmt.Println(cap(li))  //5
li = append(li, 123)
fmt.Println(li) //[1 2 3 4 5 123]
fmt.Println(cap(li)) //10
li = append(li, 456)
fmt.Println(li) //[1 2 3 4 5 123 456]
fmt.Println(cap(li)) //10,空间还没有占完，所以还没有扩展



数组：v中的元素数（与len（v）相同）。
指向数组的指针：* v中的元素数（与len（v）相同）。
切片：切片后可以达到的最大长度；
如果v为零，则cap（v）为零。
Channel：通道缓冲容量，以元素为单位；
如果v为零，则cap（v）为零。

7.常量定义关键字const

const (
	CodeSuccess ResCode = 1000 + iota
	CodeInvalidParam
	CodeUserExist
	CodeUserNotExist
	CodeInvalidPassword
	CodeServerBusy
)

8.常量定义iota枚举

常量声明可以使用iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。

在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一。

const (
	CodeSuccess ResCode = 1000 + iota
	CodeInvalidParam
	CodeUserExist
	CodeUserNotExist
	CodeInvalidPassword
	CodeServerBusy
)

const (
    x = iota // x == 0
    y = iota // y == 1
    z = iota // z == 2
    w  // 这里隐式地说w = iota，因此w == 3。其实上面y和z可同样不用"= iota"
)

const v = iota // 每遇到一个const关键字，iota就会重置，此时v == 0

const (
    h, i, j = iota, iota, iota //h=0,i=0,j=0 iota在同一行值相同
)

const (
    a       = iota //a=0
    b       = "B"
    c       = iota             //c=2
    d, e, f = iota, iota, iota //d=3,e=3,f=3
    g       = iota             //g = 4
)

const (
    x1 = iota * 10 // x1 == 0
    y1 = iota * 10 // y1 == 10
    z1 = iota * 10 // z1 == 20
)

9.append元素追加

li := []int{1, 2, 3, 4}
li = append(li, 111)
fmt.Println(li)  //[1 2 3 4 111]

10.reflect反射

方法归纳

reflect.DeepEqual(m1, m2) // 判断两个map是否相等
v := reflect.ValueOf(a) // 获取值信息

t: = reflect.TypeOf 获取类型信息, 是动态的
k := t.Kind()// kind()可以获取具体类型

v.SetFloat(6.9)  //反射修改值
v.Elem().SetFloat(7.9)// Elem()获取地址指向的值

反射类型判断

reflect.Ptr  //指针
reflect.Struct //结构体


//判断是否为指针
typeInfo := reflect.TypeOf(result)
	if typeInfo.Kind() != reflect.Ptr {
		return
	}
const (
	Invalid Kind = iota
	Bool
	Int
	Int8
	Int16
	Int32
	Int64
	Uint
	Uint8
	Uint16
	Uint32
	Uint64
	Uintptr
	Float32
	Float64
	Complex64
	Complex128
	Array
	Chan
	Func
	Interface
	Map
	Ptr
	Slice
	String
	Struct
	UnsafePointer
)

reflect.DeepEqual 判断两个map是否相等

reflect.DeepEqual(m1, m2) // 判断两个map是否相等
package main

import (
	"fmt"
	"reflect"
)

func main() {
  // m1,m2顺序不一样，做比较
	m1 := map[string]interface{}{"a": 1, "b": 2, "c": 3}
	m2 := map[string]interface{}{"a": 1, "c": 3, "b": 2}

	fmt.Println(reflect.DeepEqual(m1, m2))  // true
}

reflect.ValueOf 获取值信息

v := reflect.ValueOf(a) // 获取值信息
package main

import (
    "fmt"
    "reflect"
)

//反射获取interface值信息

func reflect_value(a interface{}) {
    v := reflect.ValueOf(a)
    fmt.Println(v)
    k := v.Kind()
    fmt.Println(k)
    switch k {
    case reflect.Float64:
        fmt.Println("a是：", v.Float())
    }
}

func main() {
    var x float64 = 3.4
    reflect_value(x)
}

//
3.4
float64
a是： 3.4

reflect.TypeOf 获取类型信息

reflect.TypeOf 获取类型信息, 是动态的
k := t.Kind()// kind()可以获取具体类型
package main

import (
   "fmt"
   "reflect"
)

//反射获取interface类型信息

func reflect_type(a interface{}) {
   t := reflect.TypeOf(a)
   fmt.Println("类型是：", t)
   // kind()可以获取具体类型
   k := t.Kind()
   fmt.Println(k)
   switch k {
   case reflect.Float64:
      fmt.Printf("a is float64\n")
   case reflect.String:
      fmt.Println("string")
   }
}

func main() {
   var x float64 = 3.4
   reflect_type(x)
}

//
类型是： float64
float64
a is float64

reflect.ValueOf(a).SetInt(10) 反射修改值

v.SetFloat(6.9)  //反射修改值
v.Elem().SetFloat(7.9)// Elem()获取地址指向的值
package main

import (
	"fmt"
	"reflect"
)

//反射修改值
func reflect_set_value(a interface{}) {
	v := reflect.ValueOf(a)
	k := v.Kind()
	switch k {
	case reflect.Float64:
		// 反射修改值
		v.SetFloat(6.9)
		fmt.Println("a is ", v.Float())
	case reflect.Ptr:
		// Elem()获取地址指向的值
		v.Elem().SetFloat(7.9)
		fmt.Println("case:", v.Elem().Float())
		// 地址
		fmt.Println(v.Pointer())
	}
}

func main() {
	var x float64 = 3.4
	// 反射认为下面是指针类型，不是float类型
	reflect_set_value(&x)
	fmt.Println("main:", x)
}

//
case: 7.9
824634957832
main: 7.9

11.结构体与反射

方法归纳

t:=reflect.TypeOf(o) //获取类型
v:=reflect.ValueOf(o) //获取值
t.NumField() //获取结构体字段个数
t.Field(i) //取每个字段
v.Field(i).Interface() //获取字段对应的值

v = v.Elem() // 获取指针指向的元素
fild := v.FieldByName("Name")  // 取字段
v.FieldByName("Age").SetInt(20)  //改年龄

m := v.MethodByName("Hello") // 获取方法
name:=v.Field(1).Interface() // 反射获取结构体字段对应的值
args := []reflect.Value{reflect.ValueOf(name)}  //构建参数
// 没参数的情况下：var args2 []reflect.Value
m.Call(args) // 调用方法，需要传入方法的参数


t := reflect.TypeOf(o) //获取类型
k:=t.NumMethod()  //绑定方法数量
m := t.Method(0) //获取方法
fmt.Println(m.Name) //获取绑定方法名称
fmt.Println(m.Type) //获取结构体类型

结构体反射

遍历结构体绑定的所有方法

package main

import (
	"fmt"
	"reflect"
)

func Poni(o interface{}) {

	t := reflect.TypeOf(o) //获取类型
	k:=t.NumMethod()  //绑定方法数量
	fmt.Println(k) //2

	for i:=0;i<k;i++{
		m := t.Method(i) //获取方法
		fmt.Println(m.Name) //获取绑定方法名称
		fmt.Println(m.Type) //获取结构体类型
	}
}

type Users struct {
	Id   int
	Name string
	Age  int
}

// 绑方法1
func (u Users) Hello() {
	fmt.Println("Hello word")
}

// 绑方法2
func (u Users) Hello2() {
	fmt.Println("Hello word2")
}

func main() {
	u := Users{1, "jeff", 18}
	Poni(u)
}

查看结构体类型、字段和方法

t := reflect.TypeOf(o) //获取类型
v := reflect.ValueOf(o) //获取值
count := t.NumField() //获取结构体字段个数
f := t.Field(i) //取每个字段
val := v.Field(i).Interface() //获取字段对应的值
package main

import (
	"fmt"
	"reflect"
)

// 定义结构体
type Users struct {
	Id   int
	Name string
	Age  int
}

// 绑方法
func (u Users) Hello() {
	fmt.Println("Hello word")
}

// 传入interface{}
func Poni(o interface{}) {
	//获取类型
	t := reflect.TypeOf(o)
	fmt.Println("类型：", t) //类型： main.Users
	fmt.Println("字符串类型：", t.Name())  //字符串类型： Users
	
	// 获取值
	v := reflect.ValueOf(o)
	fmt.Println(v)  //{1 jeff 18}
	
	// 可以获取所有属性
	// 获取结构体字段个数：t.NumField()
	for i := 0; i < t.NumField(); i++ {
		// 取每个字段
		f := t.Field(i)
		fmt.Println(f.Name, f.Type) //Id int
		
		// 获取字段的值信息
		// Interface()：获取字段对应的值
		val := v.Field(i).Interface()
		fmt.Println("data:", val)  // data: 1
	}
	fmt.Println("=================方法====================")
	for i := 0; i < t.NumMethod(); i++ {
		m := t.Method(i)
		fmt.Println(m.Name) // Hello
		fmt.Println(m.Type) //func(main.Users)
	}
	
}

func main() {
	u := Users{1, "jeff", 18}
	Poni(u)
}

查看匿名字段

package main

import (
	"fmt"
	"reflect"
)

// 定义结构体
type Users struct {
	Id   int
	Name string
	Age  int
}

// 匿名字段
type Boy struct {
	Users
	Addr string
}

func main() {
	m := Boy{Users{1, "jeff", 18}, "shanghai"}
	t := reflect.TypeOf(m)
	fmt.Println(t) //main.Boy
	// Anonymous：匿名
	fmt.Printf("%#v\n", t.Field(0))
	// 值信息
	fmt.Printf("%#v\n", reflect.ValueOf(m).Field(0)) //main.Users{Id:1, Name:"jeff", Age:18}
}

//

main.Boy
reflect.StructField{Name:"Users", PkgPath:"", Type:(*reflect.rtype)(0x10bb140), Tag:"", Offset:0x0, Index:[]int{0}, Anonymous:true}
main.Users{Id:1, Name:"jeff", Age:18}

修改结构体的值

v := reflect.ValueOf(o)  
v = v.Elem() // 获取指针指向的元素
f := v.FieldByName("Name")  // 取字段
v.FieldByName("Age").SetInt(20)  //改年龄
package main

import (
	"fmt"
	"reflect"
)

// 定义结构体
type Users struct {
	Id   int
	Name string
	Age  int
}

// 修改结构体值
func SetValue(o interface{}) {
	v := reflect.ValueOf(o)
	// 获取指针指向的元素
	v = v.Elem()
	// 取字段
	f := v.FieldByName("Name")
	if f.Kind() == reflect.String {
		f.SetString("chary")
	}
	//改年龄
	v.FieldByName("Age").SetInt(999)
}

func main() {
	u := Users{1, "jeff", 18}
  fmt.Println(u)  //{1 jeff 18}
	SetValue(&u)
	fmt.Println(u) //{1 chary 999}
}

//
{1 chary 20}

调用方法

m := v.MethodByName("Hello") // 获取方法
name:=v.Field(1).Interface() // 反射获取结构体字段对应的值
args := []reflect.Value{reflect.ValueOf(name)}  //构建参数
// 没参数的情况下：var args2 []reflect.Value
m.Call(args) // 调用方法，需要传入方法的参数
package main

import (
	"fmt"
	"reflect"
)

// 定义结构体
type Users struct {
	Id   int
	Name string
	Age  int
}

func (u Users) Hello(name string) {
	fmt.Println("Hello：", name)
}

func main() {
	u := Users{1, "jeff", 18}
	v := reflect.ValueOf(u)
	// 获取方法
	m := v.MethodByName("Hello")
	
	// 反射获取结构体字段对应的值
	name:=v.Field(1).Interface()
	// 构建一些参数
	args := []reflect.Value{reflect.ValueOf(name)}
	// 没参数的情况下：var args2 []reflect.Value
	// 调用方法，需要传入方法的参数
	m.Call(args)
}

//
Hello:jeff

获取字段的tag

package main

import (
	"fmt"
	"reflect"
)

type Student struct {
	Name string `json:"name1" db:"name2"`
}

func main() {
	var s Student
	v := reflect.ValueOf(&s)
	// 类型
	t := v.Type()
	// 获取字段
	f := t.Elem().Field(0)
	fmt.Println(f.Tag.Get("json")) //name1
	fmt.Println(f.Tag.Get("db"))  //name2
}

12.time模块

打印当前时间戳

fmt.Println(time.Now().Unix())# 1606879472

str格式化时间

time.Now() 是要格式化的时间
fmt.Println(time.Now().Format("2006-01-02 15:04:05")) # 这是个奇葩,必须是这个时间点, 据说是go诞生之日, 记忆方法:6-1-2-3-4-5
# 2020-12-02 11:25:12

时间戳转str格式化时间

str_time := time.Unix(1606879911, 0).Format("2006-01-02 15:04:05")
fmt.Println(str_time) 
# 2020-12-02 11:31:51

str格式化时间转时间戳

the_time := time.Date(2020, 12, 1, 1, 00, 0, 0,time.Local)
unix_time := the_time.Unix()
fmt.Println(unix_time)# 1606755600

time.Parse格式化时间转时间戳

the_time, err := time.Parse("2006-01-02 15:04:05", "2020-12-01 09:04:41")
if err == nil {
    unix_time := the_time.Unix()
    fmt.Println(unix_time)
  }
# 1606813481 

time.Parse和time.Format的区别

在windows下，time.Parse()的时区和time.Format()的时区是一致的。但是在linux环境下，time.Parse()的默认时区是UTC（与我们使用的标准时间CST相差8个小时），time.Format()的时区默认是本地，两者如果不处理好就会导致错误。具体可以做如下一个操作，找一台linux主机，将其/etc/localtime由Shanghai更换为UTC，然后分别执行如下代码，看下输出的区别：

package mainimport "time"import "fmt"func main(){    t, err := time.Parse("2006-01-02 15:04:05", "2017-12-03 22:01:02")    //localTime, err := time.ParseInLocation("2006-01-02 15:04:05", "2017-12-03 22:01:02", time.Local)    if err != nil{        fmt.Println(err)        return    }    fmt.Println(t)    fmt.Println(time.Now())    fmt.Println(time.Now().Sub(t).Seconds())}

分别使用time.Parse和time.ParseInLocation分别算下两个时间之间的差值，看下哪一个求出的值是正确的？

Format

now := time.Now()
fmt.Println(now)  //2021-07-13 11:26:39.500074 +0800 CST m=+0.002081543
edidate := now.Format("20060102150405")
fmt.Println(edidate)  // 20210713112639

int型时间数字处理

timestamp := int64(1640534400)
now := time.Unix(timestamp, 0).Format("2006-01")

pg时间格式timestamp读取到结构体

import "time"

sqlstr := `
	select
	coalesce(id,0) as id,
	coalesce(code,'') as code,
	coalesce(name,'') as name,
	coalesce(company,'') as company,
	coalesce(updated_at,'1970-01-01'::timestamp) as updated_at
	from bike_brand
	where 1=1
	`
	sqlstr += qstr
	err := o.DbRo.QueryRow(sqlstr).Scan(&r.Id, &r.Code, &r.Name, &r.Company, &r.UpdatedAt)


type Info struct {
	Id      	int     	`json:"id"`
	Code     	string  	`json:"code"`
	Name    	string     	`json:"name"`
	Company		string		`json:"company"`
	UpdatedAt	time.Time   `json:"updated_at"`
}

示例

最后再给出一个输出当前时间年、月、日、时等不同信息的示例代码，如下：

package main
import(    
  "fmt"    
  "time"
)
func  main(){    
  t := time.Now()    
  y,m,d := t.Date()    
  today := time.Now().Format("2006-01-02")    
  datetime := time.Now().Format("2006-01-02 15:04:05")//后面的参数是固定的 否则将无法正常输出    
  fmt.Println("time is : ",t )    
  fmt.Println("y m d is : ",y,m,d )    
  fmt.Println("now is :",today)    
  fmt.Println("now is :",datetime)
}

2020-12-02 11:42:48.606258 +0800 CST m=+0.000126668
2020 December 2
2020-12-02
2020-12-02 11:42:48

13.rand随机

# 时间戳为种子
r := rand.New(rand.NewSource(time.Now().UnixNano()))
for i:=0;i<10;i++{
		fmt.Println(r.Intn(100))
	}


rand.NewSource(种子)  设置种子
rand.Intn(100) 返回一个随机的整数
rand.Float64() 返回一个64位浮点数


//step1: 设置种子数
rand.Seed(time.Now().UnixNano())
//step2：获取随机数
num4 := rand.Intn(10) // 0-9随机数
fmt.Println(num4)


r := rand.New(rand.NewSource(time.Now().UnixNano()))
res := r.Intn(right-left+1)+left  # left到right

从切片中随机取值

# 定义随机种子
r := rand.New(rand.NewSource(time.Now().UnixNano()))

lis := make([]int,0)  //定义切片
// 给切片造假数据
for i:=0;i<100;i++ {
  lis = append(lis, i)
}
fmt.Println(lis)

for i:=0;i<10;i++ {
  a := len(lis) //获取切片长度
  b := r.Intn(a) //随机获取一个长度以内的整数
  fmt.Println(lis[b])  //取值
}

订单编号

// 生产n位数字，主用作验证码
func RandomInt(length int) (str string) {
	// length 长度
	var arr []byte = []byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	size := len(arr)
	for i := 0; i < length; i++ {
		str += string(arr[r.Intn(size)])
	}
	return
}

// 订单编号
func Start(userId int, num str) string {
  // num 以什么结尾
	now := time.Now()
	uidStr := fmt.Sprintf("%04d", userId)
	return now.Format("0601021504") + uidStr + qutil.RandomInt(3) + string(orderChannel)
}

雪花算法

地址：github.com/bwmarrin/snowflake

调用一次GenID()产生一个有序且唯一的id.

如果多台机器，可以把GenID()方法做成一个服务，调用即可
注意：可以用69年，每毫秒可以产生40多万个不重复的id

package main

import (
	"fmt"
	"time"

	"github.com/bwmarrin/snowflake"
)

var node *snowflake.Node

func Init(startTime string, machineId int64) (err error) {
	var st time.Time
	st, err = time.Parse("2006-01-02", startTime)
	if err != nil {
		return
	}
	snowflake.Epoch = st.UnixNano() / 1000000
	node, err = snowflake.NewNode(machineId)
	return
}

func GenID() (id int64, err error) {
	if err := Init("2021-01-13", 1); err != nil {
		fmt.Printf("init failed,err:%V\n", err)
		return 0, err
	}
	id = node.Generate().Int64()
	return id, nil
}

func main() {
	id, err := GenID()
	fmt.Println(id)
	fmt.Println(err)
}

14.Go语言标准库flag基本使用

Go语言标准库flag基本使用

15.MD5使用

package pkg

import (
	"crypto/md5"
	"encoding/hex"
)

var md5Pool = sync.Pool{
	New: func() interface{} {
		return md5.New()
	},
}

func MD5(str string) string {
	h := md5.New()
        //使用对象池
        //h := md5Pool.Get().(hash.Hash)
	str = str + "加盐加盐"
	h.Write([]byte(str)) // 需要加密的字符串为 123456
	cipherStr := h.Sum(nil)
	return hex.EncodeToString(cipherStr) // 输出加密结

}

16.murmurhash3非加密哈希

加密哈希，如MD5，SHA256等，
非加密哈希，如MurMurHash，CRC32，DJB等

能够满足这样的哈希算法有很多，这里推荐 Google 出品的 MurmurHash 算法，MurmurHash 是一种非加密型哈希函数，适用于一般的哈希检索操作。与其它流行的哈希函数相比，对于规律性较强的 key，MurmurHash 的随机分布特征表现更良好。非加密意味着着相比 MD5，SHA 这些函数它的性能肯定更高（实际上性能是 MD5 等加密算法的十倍以上），也正是由于它的这些优点，所以虽然它出现于 2008，但目前已经广泛应用到 Redis、MemCache、Cassandra、HBase、Lucene 等众多著名的软件中。

package main

import "fmt"
import "github.com/spaolacci/murmur3"

func main() {
	b := murmur3.Sum32WithSeed([]byte("hello word"),0x1234ABCD)
	fmt.Println(b) //1380922724

	foo := int64(murmur3.Sum64WithSeed([]byte("hello word"), 0x1234ABCD))
	fmt.Println(foo) //4946771540764450955
}

17.json

strings.Join字符串拼接

var NetworkSql string
for i := range in.Network {
  NetworkSql = strings.Join([]string{NetworkSql, strconv.Itoa(in.Network[i])}, ",")
}
NetworkSql = string(NetworkSql)[1:]

json字符串转换

import "encoding/json"
json.Marshal(query)  # 转换为json字符串
json.Unmarshal(strquery)  # json字符串转换为标准json


type Student struct {
	Name    string
	Age     int
	Classes []string
	Price   float32
}



func main() {

	st := &Student {
		"jeff",
		18,
		[]string{"math", "English", "Chinese"},
		9.99,
	}
	b, _ := json.Marshal(st)
	fmt.Println(string(b))  //{"Name":"jeff","Age":18,"Classes":["math","English","Chinese"],"Price":9.99}

	stb := &Student{}
	_ = json.Unmarshal([]byte(b), &stb)
	fmt.Println(stb) //&{jeff 18 [math English Chinese] 9.99}
}

redis map转结构体

package main

import (
	"encoding/json"
	"fmt"
	"github.com/go-redis/redis"
)

var rdb *redis.Client

func initClient() (err error) {
	rdb = redis.NewClient(&redis.Options{
		Addr:     "127.0.0.1",
		Password: "", // no password set
		DB:       4,  // use default DB
	})

	_, err = rdb.Ping().Result()
	if err != nil {
		return err
	}
	return nil
}

type bike struct {
	Acc string `json:"acc"`
	CcID string `json:"cc_id"`
}

func main() {
	err := initClient()
	if err != nil {
		fmt.Println(err)
	}
	value, err2 := rdb.HGetAll("br:10066").Result()
	if err2 != nil {
		fmt.Println(err2)
	}
	//fmt.Printf("%T",value) //map[string]string
	//fmt.Println(value)
	//// 遍历每一个字段
	//a:=value["cc_id"]
	//fmt.Println(a) // 10066
	//// 每一个字段一个个初始化，怎么样可以直接传入&bike,自动初始化
	//b := bike{
	//	Cc_id: a,
	//}
	//fmt.Printf("%+v",b) // {cc_id:10066}

	//var src []map[string]string

	json_ret, err := json.Marshal(value)
	if err != nil {
		fmt.Println(err)
	}
	var bike_test bike
	err = json.Unmarshal(json_ret, &bike_test)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("%+v", bike_test)
}

json字符串转结构体

例子1：

type Info struct {
	Id      int    `json:"id"`
	Code    string `json:"code"`
	HwCode  string `json:"hw_code"`
	Name    string `json:"name"`
	BrandId int    `json:"brand_id"`
}

func jsonTest1()  {
	jsonStr := `{"id":2,"code":"W01","hw_code":"AA5","name":"秋月白","brand_id":1}`
	r:=Info{}
	str:=[]byte(jsonStr)
	json.Unmarshal([]byte(str),&r)
	fmt.Println(r) //{2 W01 AA5 秋月白 1}
}

例子2：[{},{},{}]

type Info struct {
	Id      int    `json:"id"`
	Code    string `json:"code"`
	HwCode  string `json:"hw_code"`
	Name    string `json:"name"`
	BrandId int    `json:"brand_id"`
}

func jsonTest2()  {
	jsonStr := `[{"id":2,"code":"W01","hw_code":"AA5","name":"秋月白","brand_id":1},{"id":3,"code":"W02","hw_code":"AA6","name":"秋月黑","brand_id":2}]`
	r:=Info{}
	list := make([]Info,0)
	var li []map[string]interface{}
	json.Unmarshal([]byte(jsonStr),&li)
	for _,v:=range li{
		arr,_:=json.Marshal(v)
		json.Unmarshal(arr,&r)
		list = append(list, r)
	}
	fmt.Println(list) // [{2 W01 AA5 秋月白 1} {3 W02 AA6 秋月黑 2}]
}

例子3：map[],redis hash

type bike struct {
	Acc string `json:"acc"`
	CcID string `json:"cc_id"`
}

func jsonTest3()  {
	err := initClient()
	if err != nil {
		fmt.Println(err)
	}
	value, err2 := rdb.HGetAll("br:10066").Result()

	if err2 != nil {
		fmt.Println(err2)
	}
	fmt.Println(value)
	json_ret, err := json.Marshal(value)
	if err != nil {
		fmt.Println(err)
	}
	var bike_test bike
	err = json.Unmarshal(json_ret, &bike_test)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("%+v", bike_test)
}

18.编码转换

import "github.com/axgle/mahonia"

func main() {
	enc := mahonia.NewEncoder("utf-8")
	//converts a  string from UTF-8 to gbk encoding.
	fmt.Println(enc.ConvertString("hello,世界"))
}

19.操作kafka

http://www.topgoer.com/%E6%95%B0%E6%8D%AE%E5%BA%93%E6%93%8D%E4%BD%9C/go%E6%93%8D%E4%BD%9Ckafka/%E6%93%8D%E4%BD%9Ckafka.html

20.操作rabitMQ

http://www.topgoer.com/%E6%95%B0%E6%8D%AE%E5%BA%93%E6%93%8D%E4%BD%9C/go%E6%93%8D%E4%BD%9CRabbitMQ/

21.decimal加减乘除

初始化一个变量
d0 := decimal.NewFromFloat(0)
设置精度 为三位 四舍五入的精度
decimal.DivisionPrecision = 3 

类型转换

var num1 float64 = 3.1
var num2 int = 2
d1 := decimal.NewFromFloat(num1).Sub(decimal.NewFromFloat(float64(num2)))

//类型转换
fmt.Println(d1.IntPart())
fmt.Println(d1.String())
fmt.Println(d1.Abs())

加法 Add

加法 Add，int+float

初始化一个变量
d0 := decimal.NewFromFloat(0)
设置精度 为三位 四舍五入的精度
decimal.DivisionPrecision = 3 

2.1 + 3 float和int相加
var num1 float64 = 2.1
var num2 int = 3
d1 := decimal.NewFromFloat(num1).Add(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "5.1"

加法 Add，float+float

2.1 + 3.1 (float和float相加)
var num1 float64 = 2.1
var num2 float64 = 3.1
d1 := decimal.NewFromFloat(num1).Add(decimal.NewFromFloat(num2))
fmt.Println(d1) // output: "5.2"

加法 Add，int+int

2 + 3 (int和int相加 可以直接相加) 
var num1 float64 = 2
var num2 float64 = 3
（d1 = num1+num2）
d1 := decimal.NewFromFloat(num1).Add(decimal.NewFromFloat(num2))
fmt.Println(d1) // output: "5"

减法 Sub

减法 Sub,float-int相减

3.1 - 2 float和int相减
var num1 float64 = 3.1
var num2 int = 2
d1 := decimal.NewFromFloat(num1).Sub(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "1.1"

减法 Sub,float-float相减

2.1 - 3.1 (float和float相减)
var num1 float64 = 2.1
var num2 float64 = 3.1
d1 := decimal.NewFromFloat(num1).Sub(decimal.NewFromFloat(num2))
fmt.Println(d1) // output: "-1"

减法 Sub,int-int相减

2 - 3 (int和int相减)
var num1 int = 2
var num2 int = 3
(d1 = num1 - num2)
d1 := decimal.NewFromFloat(float64(num1)).Sub(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "-1"

乘法 Mul

乘法 Mul,float*int

3.1 * 2 float和int相乘
var num1 float64 = 3.1
var num2 int = 2
d1 := decimal.NewFromFloat(num1).Mul(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "6.2"

乘法 Mul,float*float

2.1 * 3.1 (float和float相乘)
var num1 float64 = 2.1
var num2 float64 = 3.1
d1 := decimal.NewFromFloat(num1).Mul(decimal.NewFromFloat(num2))
fmt.Println(d1) // output: "6.51"

乘法 Mul,int*int

2 * 3 (int和int相乘)
var num1 int = 2
var num2 int = 3
(d1 = num1 * num2)
d1 := decimal.NewFromFloat(float64(num1)).Mul(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "6"

除法 Div

除法 Div,int/int

int 和 int 相除
2 ➗ 3 = 0.6666666666666667 
var num1 int = 2
var num2 int = 3
d1 := decimal.NewFromFloat(float64(num1)).Div(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "0.6666666666666667"

除法 Div,float64/int

float64 和 int 相除
var num1 float64 = 2.1
var num2 int = 3
d1 := decimal.NewFromFloat(num1).Div(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "0.7"

除法 Div,float64/float64

float64 和 float64 相除
2.1 ➗ 0.3 = 7
var num1 float64 = 2.1
var num2 float64 = 0.3
d2 := decimal.NewFromFloat(num1).Div(decimal.NewFromFloat(num2))
fmt.Println(d2) // output: "7"

除法 Div,int/int

int 和 int 相除 并保持3位精度
2 ➗ 3 = 0.667 
var num1 int = 2
var num2 int = 3
decimal.DivisionPrecision = 3
d1 := decimal.NewFromFloat(float64(num1)).Div(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "0.667"

22.in

func in(target int, str_array []int) bool {
	for _, element := range str_array {
		if target == element {
			return true
		}
	}
	return false
}

23.排序

字符串排序

方式一：
func reverse(str string) string {
    var result string
    strLen := len(str)
    for i := 0; i < strLen; i++ {
        result = result + fmt.Sprintf("%c", str[strLen-i-1])
    }
    return result
}

方式二：
func reverse2(str string) string {
    var result []byte
    tmp := []byte(str)
    length := len(str)
    for i := 0; i < length; i++ {
        result = append(result, tmp[length-i-1])
    }
    return string(result)
}

方式三：
func reverse13(s string) string {
	runes := []rune(s)
	for from, to := 0, len(runes)-1; from < to; from, to = from+1, to-1 {
		runes[from], runes[to] = runes[to], runes[from]
	}
	return string(runes)
}

切片排序

r := []int{5,2,6,10,3} // []int{}
sort.Ints(r)  // 升序
sort.Sort(sort.IntSlice(r)) //升序
fmt.Println(r) // [2 3 5 6 10]


a := []float64{5.5, 2.2, 6.6, 3.3, 1.1, 4.4}
sort.Float64s(a) // 升序
sort.Sort(sort.Float64Slice(a)) // 升序
fmt.Println(a) // [1.1 2.2 3.3 4.4 5.5 6.6]


s := []string{"PHP", "golang", "python", "C", "Objective-C"}
sort.Strings(s) // 字母开头升序
sort.Sort(sort.StringSlice(s)) //字母开头升序
fmt.Println(s) // [C Objective-C PHP golang python]

逆序：
func reverse(s []int) []int {
	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
		s[i], s[j] = s[j], s[i]
	}
	return s
}
func main() {
	r := []int{5,2,6,10,3}
	k:=reverse(r) // 逆序
	fmt.Println(k) // [3 10 6 2 5]

	sort.Ints(r)  // 升序
	fmt.Println(r) // [2 3 5 6 10]

	k2:=reverse(r) // 逆序
	fmt.Println(k2) // [10 6 5 3 2]
}

24.math数学计算

//math包中定义的常量
func main() {
	fmt.Printf("float64的最大值是:%.f\n", math.MaxFloat64)
	fmt.Printf("float64的最小值是:%.f\n", math.SmallestNonzeroFloat64)
	fmt.Printf("float32的最大值是:%.f\n", math.MaxFloat32)
	fmt.Printf("float32的最小值是:%.f\n", math.SmallestNonzeroFloat32)
	fmt.Printf("Int8的最大值是:%d\n", math.MaxInt8)
	fmt.Printf("Int8的最小值是:%d\n", math.MinInt8)
	fmt.Printf("Uint8的最大值是:%d\n", math.MaxUint8)
	fmt.Printf("Int16的最大值是:%d\n", math.MaxInt16)
	fmt.Printf("Int16的最小值是:%d\n", math.MinInt16)
	fmt.Printf("Uint16的最大值是:%d\n", math.MaxUint16)
	fmt.Printf("Int32的最大值是:%d\n", math.MaxInt32)
	fmt.Printf("Int32的最小值是:%d\n", math.MinInt32)
	fmt.Printf("Uint32的最大值是:%d\n", math.MaxUint32)
	fmt.Printf("Int64的最大值是:%d\n", math.MaxInt64)
	fmt.Printf("Int64的最小值是:%d\n", math.MinInt64)
	fmt.Printf("圆周率默认为:%.200f\n", math.Pi)
}


func main() {
	/*
	   取绝对值,函数签名如下:
	       func Abs(x float64) float64
	*/
	fmt.Printf("[-3.14]的绝对值为:[%.2f]\n", math.Abs(-3.14))

	/*
	   取x的y次方，函数签名如下:
	       func Pow(x, y float64) float64
	*/
	fmt.Printf("[2]的16次方为:[%.f]\n", math.Pow(2, 16))

	/*
	   取余数，函数签名如下:
	       func Pow10(n int) float64
	*/
	fmt.Printf("10的[3]次方为:[%.f]\n", math.Pow10(3))

	/*
	   取x的开平方，函数签名如下:
	       func Sqrt(x float64) float64
	*/
	fmt.Printf("[64]的开平方为:[%.f]\n", math.Sqrt(64))

	/*
	   取x的开立方，函数签名如下:
	       func Cbrt(x float64) float64
	*/
	fmt.Printf("[27]的开立方为:[%.f]\n", math.Cbrt(27))

	/*
	   向上取整，函数签名如下:
	       func Ceil(x float64) float64
	*/
	fmt.Printf("[3.14]向上取整为:[%.f]\n", math.Ceil(3.14))

	/*
	   向下取整，函数签名如下:
	       func Floor(x float64) float64
	*/
	fmt.Printf("[8.75]向下取整为:[%.f]\n", math.Floor(8.75))

	/*
	   取余数，函数签名如下:
	       func Floor(x float64) float64
	*/
	fmt.Printf("[10/3]的余数为:[%.f]\n", math.Mod(10, 3))

	/*
	   分别取整数和小数部分,函数签名如下:
	       func Modf(f float64) (int float64, frac float64)
	*/
	Integer, Decimal := math.Modf(3.14159265358979)
	fmt.Printf("[3.14159265358979]的整数部分为:[%.f],小数部分为:[%.14f]\n", Integer, Decimal)

}

25.strings

strings.EqualFold 判断两个utf-8编码字符串是否相同

func main()  {
	s:="jeff"
	t:="jeff"
  k:= "chary"
	fmt.Println(strings.EqualFold(s,t))  // true
  fmt.Println(strings.EqualFold(s,k))  // false
}

strings.HasPrefix 判断s字符串是否有前缀字符串p

func main()  {
	s:="jeff"
	fmt.Println(strings.HasPrefix(s,"j"))  //true
	fmt.Println(strings.HasPrefix(s,"e"))  //false
}

strings.HasSuffix 判断s字符串是否有后缀缀字符串p

func main()  {
	s:="jeff"
	fmt.Println(strings.HasSuffix(s,"f"))  //true
	fmt.Println(strings.HasSuffix(s,"j"))  //false
}

strings.Count 判断s字符串有几个不重复的sep子串

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.Count(s,"f"))  // 2
	fmt.Println(strings.Count(s,"kkk"))  // 0
}

strings.Contains 判断s字符串是否包含字符串p

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.Contains(s,"word"))  //true
	fmt.Println(strings.Contains(s,"kkk"))  //false
}

strings.ContainsAny 判断s字符串是否包含字符p

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.ContainsAny(s,"word"))  //true
	fmt.Println(strings.ContainsAny(s,"kkk"))  //false
}

strings.ContainsRune 判断s字符串是否包含指定ASCII码值

a-z：97-122
A-Z：65-90
0-9：48-57

func main()  {
	s:="aaa hello word jeff"
	fmt.Println(strings.ContainsRune(s,97))  //true
	fmt.Println(strings.ContainsRune(s,98))  //false
}

strings.IndexByte/IndexRune 判断指定ASCII码值在s字符串中的位置，不存在返回-1

a-z：97-122
A-Z：65-90
0-9：48-57
func main()  {
	s:="hello word jeff aaa"
	fmt.Println(strings.IndexByte(s,97))  // 16
  fmt.Println(strings.IndexByte(s,'a'))  // 16
	fmt.Println(strings.IndexByte(s,98))  // -1
}

strings.Index 判断字符串p在s字符串出现的位置，不存在返回-1

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.Index(s,"word"))  // 6
	fmt.Println(strings.Index(s,"h"))  // 1
	fmt.Println(strings.Index(s,"kkk"))  // -1
}

strings.IndexAny 字符串p中的任一utf-8码值在s中第一次出现的位置,没有返回-1

func main()  {
	s:="hello word jeff aaa"
	fmt.Println(strings.IndexAny(s,"ekkk"))  // 1
	fmt.Println(strings.IndexAny(s,"kkk"))  // -1
}

strings.Title 首字母都改为大写

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.Title(s))  //Hello Word Jeff
  fmt.Println(strings.ToTitle(s))  //Hello Word Jeff  标题版
}

strings.ToLower 所有转小写

func main()  {
	s:="HELLO WORD JEFF"
	fmt.Println(strings.ToLower(s))  //hello word jeff
}

strings.ToUpper 所有转大写

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.ToUpper(s))  //HELLO WORD JEFF
}

strings.Repeat 拷贝n个s字符串

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.Repeat(s,2))  //hello word jeffhello word jeff
}

strings.Replace 字符串替换

返回将s中前n个不重叠old子串都替换为new的新字符串，如果n<0会替换所有old子串。
func main()  {
	s:="hello word jeff"
  //前面1个"h"替换为“k”
	fmt.Println(strings.Replace(s,"h","k",1))  //kello word jeff
  
  //所有的"o"替换为"k"
  fmt.Println(strings.Replace(s,"o","k",-1))  //hellk wkrd jeff
}

strings.Trim 返回用p包裹的中间字符串

func main()  {
	s:="!!!hello word jeff !!!"
	fmt.Println(strings.Trim(s,"!"))  //hello word jeff
}

strings.TrimLeft 去掉左边包裹

func main()  {
	s:="!!!hello word jeff !!!"
	fmt.Println(strings.TrimLeft(s,"!"))  //hello word jeff !!!
}

strings.TrimRight 去掉右边包裹

func main()  {
	s:="!!!hello word jeff !!!"
	fmt.Println(strings.TrimRight(s,"!"))  //!!!hello word jeff
}

strings.TrimSpace 去掉前后空格

func main()  {
	s:="   hello word jeff  "
	fmt.Println(strings.TrimSpace(s))  //hello word jeff
}

strings.TrimPrefix 返回去除s可能的前缀prefix的字符串

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.TrimPrefix(s,"hello"))  // word jeff
	fmt.Println(strings.TrimPrefix(s,"word"))  //hello word jeff
}

strings.TrimSuffix 返回去除s可能的后缀prefix的字符串

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.TrimSuffix(s,"jeff"))  //hello word
	fmt.Println(strings.TrimPrefix(s,"word"))  //hello word jeff
}

strings.Fields 字符串按照空格转为切片

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.Fields(s))  //[hello word jeff]
}

strings.Split 切割

func main()  {
   s:="hello,word,jeff"
   fmt.Println(strings.Split(s,","))  //[hello word jeff]
}

strings.SplitN 切割条件

func main()  {
   s:="hello word jeff"
   fmt.Println(strings.SplitN(s,"",3))  //[h e llo word jeff]
}

strings.Join 字符串拼接

func main()  {
	s:= []string{"hello", "word", "jeff"}
	fmt.Println(strings.Join(s,","))  //hello,word,jeff
}


var NetworkSql string
for i := range in.Network {
  NetworkSql = strings.Join([]string{NetworkSql, strconv.Itoa(in.Network[i])}, ",")
}
NetworkSql = string(NetworkSql)[1:]


func main()  {
	var k string
	s:= []int{1, 2, 3}
	for i:= range(s){
		k = strings.Join([]string{ k,strconv.Itoa(i)},",")
	}
	fmt.Println(k) // ,0,1,2
}

26.os包

其他方法官方地址：https://studygolang.com/pkgdoc

os.Getenv-读取环境变量key

//Getenv检索并返回名为key的环境变量的值。如果不存在该环境变量会返回空字符串。
data := os.Getenv("GOPATH")
fmt.Println(data) ///Users/jeff/go

os.Environ-读取所有环境变量

// Environ返回表示环境变量的格式为"key=value"的字符串的切片拷贝
data:= os.Environ() 
fmt.Println(data) //[...很多]

os.Setenv-设置环境变量

//Setenv设置名为key的环境变量。如果出错会返回该错误。
err := os.Setenv("Jeff","帅哥")
fmt.Println(err)

data := os.Getenv("Jeff")
fmt.Println(data) //帅哥

os.Clearenv-清空环境变量

//Clearenv删除所有环境变量。
os.Clearenv()
data:= os.Environ() //读取所有环境变量
fmt.Println(data) //[]

os.Hostname-获取主机名称

//Hostname返回内核提供的主机名。
data, _ := os.Hostname()
fmt.Println(data) //JeffMacBook-Pro.local

os.Getuid-返回调用者的用户ID

//Getuid返回调用者的用户ID。
data:= os.Getuid()
fmt.Println(data) //501

os.Geteuid-返回调用者的有效用户ID

//Getuid返回调用者的有效用户ID。
data:= os.Geteuid()
fmt.Println(data) //501

os.Getgid-返回调用者的组ID

//Getuid返回调用者的组ID。
data:= os.Getgid()
fmt.Println(data) //20

os.Getegid-返回调用者的有效组ID

//Getuid返回调用者的有效组ID。
data:= os.Getegid()
fmt.Println(data) //20

os.Getpid-调用者所在进程的进程ID

// Getpid返回调用者所在进程的进程ID。
data:= os.Getpid()
fmt.Println(data) // 54835

os.Getppid-调用者所在进程的父进程的进程ID

// Getppid返回调用者所在进程的父进程的进程ID。
data:= os.Getppid()
fmt.Println(data) // 54835

os.Getwd-当前工作目录的根路径

// Getwd返回一个对应当前工作目录的根路径。
data,_:=os.Getwd()
fmt.Println(data)///Users/jeff/Desktop/test

os.Chdir-修改工作路径

// Chdir将当前工作目录修改为dir指定的目录
_=os.Chdir("/Users/jeff/Desktop/")

data,_:=os.Getwd()
fmt.Println(data) ///Users/jeff/Desktop/

os.Mkdir-创建目录

//Mkdir使用指定的权限和名称创建一个目录。
err:=os.Mkdir("./file",os.ModePerm)
fmt.Println(err)

os.MkdirAll-创建层级目录

//Mkdir使用指定的权限和名称创建一个层级目录。
err:=os.MkdirAll("./data/file",os.ModePerm)
fmt.Println(err)

os.Rename-修改文件名字

//Rename修改一个文件的名字，移动一个文件。
func Rename(oldpath, newpath string) error

err:=os.Rename("./file","./file2")
fmt.Println(err)

os.Remove-删除文件或目录

// Remove删除name指定的文件或目录。
err:=os.Remove("./file.txt")
fmt.Println(err) 

os.RemoveAll-层级删除

// Remove删除name指定的文件或目录。
err:=os.RemoveAll("./data")
fmt.Println(err)