GoLang萌新自用总结参考手册

大佬们自行绕过，本人萌新，随着工作之余抽时间学习，持续补充ing...

defer栈，后入先出，后定义先调用
形如go func(){}()的闭包协程调用，如果不传递参数，那么在闭包内使用闭包外部的变量，使用的是地址，跟随外部变化
函数调用时，根据所属结构体调用相应方法
切片使用make初始化时，定义长度为3，那么未定义默认值的部分为0，再调用append追加元素，从第4个元素开始
默认引用传递：slice、map、channel
for循环中不会每次循环的时候都新建循环变量，所以循环内赋值和取地址，应定义临时变量，而不应使用循环变量
interface变量使用前需要断言（判断和转换变量类型）
map的key如果不是整形有序的，range是随机遍历

int转string

data := 12
res := strconv.FormatInt(int64(data), 10)
res1 := strconv.Itoa(data)
fmt.Println( reflect.TypeOf(res) )
fmt.Println( reflect.TypeOf(res1) )

float转string

data := 12.12
res := strconv.FormatFloat(data, 'f', -1, 32)
fmt.Println( reflect.TypeOf(res) )
fmt.Println( res )

string转float

data := "12.12"
res, err := strconv.ParseFloat(data, 32)
if err != nil{
	panic(err)
}
fmt.Println( reflect.TypeOf(res) )
fmt.Println( res )

string转int

data := "12"
res, err := strconv.ParseInt(data, 10, 64)
res1, err := strconv.Atoi(data)
if err != nil{
	panic(err)
}
fmt.Println( reflect.TypeOf(res) )
fmt.Println( res )
fmt.Println( reflect.TypeOf(res1) )
fmt.Println( res1 )

不同位int之间转换

fmt.Println(reflect.TypeOf(int(12)))
fmt.Println(reflect.TypeOf(int8(12)))
fmt.Println(reflect.TypeOf(int32(12)))
fmt.Println(reflect.TypeOf(int32(12)))
fmt.Println(reflect.TypeOf(int64(12)))

除法保留小数

float64(113422)/float64(1000)

分割数组和连接字符串

str := "why/test"
fmt.Println( strings.Join(strings.Split(str, "/"), "-" ))

根据指定字符串查找目标字符串是否存在，存在的话前后切割数组

func substr(str string, target string, turn string, hasPos bool) string {
	pos := strings.Index(str, target)

	if pos == -1 {
		return ""
	}

	if turn == "left" {
		if hasPos == true{
			pos = pos + 1
		}
		return str[:pos]
	}else if turn == "right" {
		if hasPos == false{
			pos = pos + 1
		}
		return str[pos:]
	}else{
		panic("params 3 error")
	}
}

时间和时间戳

time.Now()  //包含时区的当前时间
time.Now().Unix()    //当前时间戳
time.Now().Format("2006-01-02 15:04:05")    //Y-m-d H:i:s

first := time.Now()
second := time.Now()
fmt.Println( second.Sub(first).Seconds() )    //时差ms

格式化保留2位小数

fmt.Printf("9.8249	=>	%0.2f(四舍)\n", 9.8249)
fmt.Printf("9.82671	=>	%0.2f(六入)\n", 9.82671)
fmt.Printf("9.8351	=>	%0.2f(五后非零就进一)\n", 9.8351)
fmt.Printf("9.82501	=>	%0.2f(五后非零就进一)\n", 9.82501)
fmt.Printf("9.8250	=>	%0.2f(五后为零看奇偶，五前为偶应舍去)\n", 9.8250)
fmt.Printf("9.8350	=>	%0.2f(五后为零看奇偶，五前为奇要进一)\n", 9.8350)  

9.8249  =>  9.82(四舍)
9.82671 =>  9.83(六入)
9.8351  =>  9.84(五后非零就进一)
9.82501 =>  9.83(五后非零就进一)
9.8250  =>  9.82(五后为零看奇偶，五前为偶应舍去)
9.8350  =>  9.84(五后为零看奇偶，五前为奇要进一)

口诀：四舍六入五考虑，五后非零就进一，五后为零看奇偶，五前为偶应舍去，五前为奇要进一

解析url

    u, err:= url.Parse("http://www.why.com:8888/why/test?id=1")
	if err != nil{
		panic(err)
	}
	fmt.Println(u.Scheme)
	fmt.Println(u.Host)

	arr := strings.Split(u.Host, ":")
	fmt.Println(arr[0])
	fmt.Println(arr[1])

	fmt.Println(u.Port())
	fmt.Println(u.Path)
	fmt.Println(u.RawQuery)

	m, _ := url.ParseQuery(u.RawQuery)
	fmt.Println(m["id"])



http
www.why.com:8888
www.why.com
8888
8888
/why/test
id=1
[1]

根据时间检测目录，不存在则创建


func CreateDateDir(Path string) string {
	folderName := time.Now().Format("20060102")
	folderPath := filepath.Join(Path, folderName)
	if _, err := os.Stat(folderPath); os.IsNotExist(err) {
		// 必须分成两步：先创建文件夹、再修改权限
		os.Mkdir(folderPath, 0777) //0777也可以os.ModePerm
		os.Chmod(folderPath, 0777)
	}
	return folderPath
}

按照请求的path建日志文件

    u, err:= url.Parse("http://www.why.com:8888/why/test?id=1")
	if err != nil{
		panic(err)
	}

	pathArr := strings.Split(u.Path, "/")
	fileName := strings.Join(pathArr, "-")
	writePath := "/tmp/logs/2020-01-12"
	fileName = path.Join(writePath, fileName[1:len(fileName)] + ".log")

	fmt.Println(pathArr)
	fmt.Println(fileName)

文件写入

//使用io.WriteString()函数进行数据的写入，不存在则创建
func WriteWithIo(filePath, content string) {
	fileObj,err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0777)
	if err != nil {
		fmt.Println("Failed to open the file",err.Error())
		os.Exit(2)
	}
	if  _,err := io.WriteString(fileObj,content);err == nil {
		fmt.Println("Successful appending to the file with os.OpenFile and io.WriteString.",content)
	}
}


参数2：
os.O_WRONLY | os.O_CREATE | O_EXCL    【如果已经存在，则失败】
os.O_WRONLY | os.O_CREATE    【如果已经存在，会覆盖写，不会清空原来的文件，而是从头直接覆盖写】
os.O_WRONLY | os.O_CREATE | os.O_APPEND    【如果已经存在，则在尾部添加写】

断言

func assertion(data interface{}) interface{}  {
	switch data.(type) {
	case string:
		return data.(string)
	case int:
		return data.(int)
	case int8:
		return data.(int8)
	case int32:
		return data.(int32)
	case int64:
		return data.(int64)
	case float32:
		return data.(float32)
	case float64:
		return data.(float64)
	default:
		return data
	}
	return nil
}