golang 日常开发小抄

一  int in64 string 转换

1. int <->string

string转成int：
int, _ := strconv.Atoi(string)

int转成string：
string := strconv.Itoa(int)

2. int64 <->string

string转成int64：
int64, _:= strconv.ParseInt(string, 10, 64)

int64转成string：
string := strconv.FormatInt(int64,10)

不是uint8 uint64转string

var a uint = 1
b := strconv.Itoa(int(a))

二  golang 时间处理

1. 将时间戳格式化为日期字符串

	ts := int64(1606110630)      //外部传入的时间戳（秒为单位），必须为int64类型
	
	//时间转换的模板，golang里面只能是 "2006-01-02 15:04:05" （go的诞生时间）
	timeTemplate1 := "2006-01-02 15:04:05" //常规类型
	timeTemplate2 := "2006/01/02 15:04:05" //其他类型
	timeTemplate3 := "2006-01-02"          //其他类型  日
	timeTemplate4 := "15:04:05"            //其他类型


	// ======= 将时间戳格式化为日期字符串 =======
	log.Println(time.Unix(ts, 0).Format(timeTemplate1)) //输出：2020-11-23 13:50:30
	log.Println(time.Unix(ts, 0).Format(timeTemplate2)) //输出：2020/11/23 13:50:30
	log.Println(time.Unix(ts, 0).Format(timeTemplate3)) //输出：2020-11-23
	log.Println(time.Unix(ts, 0).Format(timeTemplate4)) //输出：13:50:30

    // 注
	logs.Info(time.Unix(1606110630,0))	// 2020-11-23 13:50:30 +0800 CST

    // 常用
    logs.Info(time.Now().Format("200601"))

	logs.Info(time.Now())         // 2020-11-24 12:03:58.5535179 +0800 CST m=+0.028925401
	logs.Info(time.Now().Unix())  // 1606190638

	// 得到昨天的日期
	currentTime := time.Now()
	oldTime := currentTime.AddDate(0, 0, -1)		//若要获取3天前的时间，则应将-1改为-3
	logs.Info(oldTime.Format("2006-01-02"))

2. ParseInLocation

	start, _ := time.ParseInLocation("2006-01-02 15:04:05", "2020-11-23 15:04:05", time.Local)

	logs.Info(start)		// 2020-11-23 15:04:05 +0800 CST
	logs.Info(time.Now())	// 2020-11-23 17:42:04.8698831 +0800 CST m=+0.031914701

3.golang 删除数组中的一个元素

	a := []int{0, 1, 2, 3, 4}
	//删除第i个元素
	i := 2
	a = append(a[:i], a[i+1:]...)
	logs.Info(a)

 

三  golang加锁与事务

1. golang 加锁

	var mu sync.Mutex
    mu.Lock()
	defer mu.Unlock()

2.golang 事务

	// 开启事务
	o:=orm.NewOrm()
	o.Begin()

     // 事务回滚
     if err!=nil{
				logs.Error(err)
				o.Rollback()
	 }
  
    // 事务提交
	err:=o.Commit()
	if err != nil {
		logs.Error("commit transaction failed.", err)
	}

3.3.1

四、MarShal Unmarshal

			1. json.Marshal  
		       map struct-> json    encode Marshal returns the JSON encoding of v.
		       示例： jsonBytes, _ := json.Marshal(apiResp.Data)
		 	2. json.Marshal
				json -> map struct
				示例： err := json.Unmarshal(jsonbts, &rc)

活体检测是用到

	logs.Info("算法端回复-->:", resultJson["data"]) 	// map[actionType:1 isLiving:0]

	dataMap:=make(map[string]string)
	jsonBytes, _ := json.Marshal(resultJson["data"])
	json.Unmarshal(jsonBytes, &dataMap)

	logs.Info("dataMap",dataMap)			// dataMap map[actionType:1 isLiving:0]
	for i, i2 := range dataMap {
		logs.Info("-->",i,i2)			// actionType 1  isLiving 0
	}

 

五、url 和 path 解析

1. url parse 解析类 每种语言都有对url的解析

	urlPath_ := "postgres://user:pass@host.com5432/path?k=v&aa=bb&&cc=dd&&id=1"
	//urlPath_ :="http://ai.cubigdata.cn:8000/smartdoor/v1/pad/access/auth/sync?id=0&&name=zgf"

	//解析url 并保证没有错误
	u, err := url.Parse(urlPath_)
	if err != nil {
		panic(err)
	}

	logs.Info(u.Scheme) // http
	logs.Info(u.User)
	u.User.Username()
	u.User.Password()
	logs.Info(u.Host) //  ai.cubigdata.cn:8000
	logs.Info(u.Path)	// /smartdoor/v1/pad/access/auth/sync
	logs.Info(u.Fragment)
	logs.Info(u.RawQuery)		// id=0&name=zgf
	logs.Info("@@")
	values,_:=url.ParseQuery(u.RawQuery)
	
	logs.Info(values)
	logs.Info(values["id"])
	logs.Info(values["id"][0])

2. 有解析url的类，就有解析path的类

	str:="/static/default/4/V1/12075e9f-31bb-45ca-8127-585ac16fee62.png"
	fmt.Println(path.Dir(str))	//  /static/default/4/V1
	fmt.Println(path.Base(str))	// 12075e9f-31bb-45ca-8127-585ac16fee62.png
	fmt.Println(path.Ext(str))	// .png

六 基本数据类型

1. map

	var q = make(map[string]interface{})
	q["a"]="aaa"
	value,ok:=q["a"]
	logs.Info(value,ok) //  aaa true
	logs.Info(q["c"])	// map 取不出来 为nil

2. 数组

1. 声明和strings类

	ss := []string{"Monday", "Tuesday", "Wednesday"}
	s := strings.Join(ss, "|")

2.数组、切片 数据类型

//数组初始化的各种方式
func arraySliceTest0201() {
	//创建数组(声明长度)
	var array1 = [5]int{1, 2, 3}
	fmt.Printf("array1--- type:%T \n", array1)
	rangeIntPrint(array1[:])
	logs.Info("----------  1 -------------")

	//创建数组(不声明长度)
	var array2 = [...]int{6, 7, 8}
	fmt.Printf("array2--- type:%T \n", array2)
	rangeIntPrint(array2[:])

	logs.Info("----------  2 -------------")


	//创建数组切片
	var array3 = []int{9, 10, 11, 12}
	fmt.Printf("array3--- type:%T \n", array3)
	rangeIntPrint(array3)
	logs.Info("----------  3 -------------")

	//创建数组(声明长度)，并仅初始化其中的部分元素
	var array4 = [5]string{3: "Chris", 4: "Ron"}
	fmt.Printf("array4--- type:%T \n", array4)
	rangeObjPrint(array4[:])
	logs.Info("----------  4 -------------")

	//创建数组(不声明长度)，并仅初始化其中的部分元素，数组的长度将根据初始化的元素确定
	var array5 = [...]string{3: "Tom", 2: "Alice"}
	fmt.Printf("array5--- type:%T \n", array5)
	rangeObjPrint(array5[:])
	logs.Info("----------  5 -------------")

	//创建数组切片，并仅初始化其中的部分元素，数组切片的len将根据初始化的元素确定
	var array6 = []string{4: "Smith", 2: "Alice"}
	fmt.Printf("array6--- type:%T \n", array6)
	rangeObjPrint(array6)
}

//输出整型数组切片
func rangeIntPrint(array []int) {
	for i, v := range array {
		fmt.Printf("index:%d  value:%d\n", i, v)
	}
}

//输出字符串数组切片
func rangeObjPrint(array []string) {
	for i, v := range array {
		fmt.Printf("index:%d  value:%s\n", i, v)
	}
}

3. 删除数组的某个元素

	a := []int{0, 1, 2, 3, 4}
	//删除第i个元素
	i := 2
	a = append(a[:i], a[i+1:]...)
	logs.Info(a)		// [0 1 3 4] //删除第i个元素
	logs.Info(a[:i])	// 0 1
	logs.Info(a[i+1:])	// 4
	logs.Info(a[0:])	// 0 1 3 4
	logs.Info(a[i:])    // 3 4

4.创建一个数组，数组里面装的都是map

	arr := make([]map[string]interface{}, 0) // 创建一个数组，数组里面装的都是map
	subMap1 := make(map[string]interface{})
	subMap1["path"] = "/1"
	subMap1["size"] = 10

	subMap2 := make(map[string]interface{})
	subMap2["path"] = "/2"
	subMap2["size"] = 20

	arr = append(arr, subMap1)
	arr = append(arr, subMap2)
	for _, a := range arr {
		logs.Info(a["path"])
		logs.Info(a["size"])
	}

七、创建map 数组 model数组

一、创建map 数组 model数组
	1.创建map
		var success = make(map[string]interface{})
		
	2.创建数组
		var allData = make([]interface{},0)
		allData=append(allData, success)
	  2.1 创建map数组
		submap:=make(map[string]interface{})	// 创建map 
		zipFilePathList:=make([]map[string]interface{},0)	// 创建map数组   
	3.创建 model 数组
		var appAbilityList = make([]models.AppAbilityModel,0)
		_, _ = api.QueryTable().Filter("ability_id", abilityID).All(&apiList) // 要加&
	  3.1 创建单个model 和 创建model数组
	  		api := &models.ApiModel{}
			apiList := make([]*models.ApiModel, 0)
	  3.2 创建数组 model model数组
	  		abilityIdList := make([]uint64, 0)
			appAbilityModel := &models.AppAbilityModel{}
			appAbilityList := make([]*models.AppAbilityModel, 0)
		
	4.扩展	
	  1.创建单个model并将数据库查询内容读入
		apiModel := &models.ApiModel{}
		err := models.NewApiModel().QueryTable().Filter("url", url).One(apiModel, "ability_id")
		或者
		label := new(models.DatasetLabel)
		_, _ = label.QueryTable(domain).Filter("label_id", labelId).All(label)
		
		api := &models.ApiModel{}
		apiList := make([]*models.ApiModel, 0)
		_, _ = api.QueryTable().Filter("ability_id", abilityID).All(&apiList)
		
		
		app:=&models.AppModel{}
		models.NewAppModel().QueryTable().Filter("id",pack.AppId).One(app)
	
	  2.创建数组model并将数据库查询内容读入
		// 待确认
		var appAbilityList = make([]*models.AppAbilityModel, 0)
		_, err = models.NewAppAbilityModel().QueryTable().Filter("ability_id", apiModel.AbilityId).All(&appAbilityList, "app_id")

		
	5.创建一个数组，装map
		arr:=make([]map[string]interface{},0)
		sub1:=make(map[string]interface{})
		sub1["path"]="path_a"
		sub1["size"]="size_a"
	
		sub2:=make(map[string]interface{})
		sub2["path"]="path_a"
		sub2["size"]="size_a"
	
	
	
		arr=append(arr,sub1)
		arr=append(arr,sub2)
		for _, a := range arr {
			logs.Info(a["path"])
			logs.Info(a["size"])
		}