Golang 基础-Cheatsheet

1. 函数

1. 转换

// 转换字符串 s string 到整型
strconv.Atoi(s string) (int, error)

// 将整型转 i int 换为字符串
strconv.Itoa(i int) string

2. 时间

1. 获取日期和时间、时间戳

// 获取当前时间，类型是Go的时间类型Time
currentTime:=time.Now()                 // 结果 2021-01-10 14:56:15.930562 +0800 CST m=+0.000124449

// 获取当前时间戳
timeUnix:=time.Now().Unix()            //单位s,结果:1491888244
timeUnixNano:=time.Now().UnixNano()    //单位纳秒,结果：1491888244752784461

// 获取当前时间
t1:=time.Now().Year()        //年
t2:=time.Now().Month()       //月
t3:=time.Now().Day()         //日
t4:=time.Now().Hour()        //小时
t5:=time.Now().Minute()      //分钟
t6:=time.Now().Second()      //秒
t7:=time.Now().Nanosecond()  //纳秒

//如果获取UTC时间，则可以使用time.UTC
currentTimeData:=time.Date(t1,t2,t3,t4,t5,t6,t7,time.Local) //获取当前时间，返回当前时间Time     

fmt.Println(currentTime)        //打印结果：2017-04-11 12:52:52.794351777 +0800 CST
fmt.Println(t1,t2,t3,t4,t5,t6)  //打印结果：2017 April 11 12 52 52
fmt.Println(currentTimeData)    //打印结果：2017-04-11 12:52:52.794411287 +0800 CST

2. 格式化时间

格式化函数 Format()，格式化时间模是 2006-01-02 15:04:05，记忆方式 2006 1 2 3 4 5

now := time.Now()                               
fmt.Println(now.Format("2006-01-02 15:03:04"))  // 2023-07-25 10:10:11
fmt.Println(now.Format("2006-01-02"))           // 2023-07-25
fmt.Println(now.Format("15:03:04"))             // 10:10:11
fmt.Println(now.Format("2006/01/02 15:04"))     // 2023/07/25 10:11
fmt.Println(now.Format("15:04 2006/01/02"))     // 10:11 2023/07/25

3. 格式化时间时间转换

时间戳转字符串 (int64 —> string)，将时间戳转成 time.Time 类型再格式化成日期格式

timeUnix:=time.Now().Unix()
formatTimeStr:=time.Unix(timeUnix,0).Format("2006-01-02 15:04:05")  // 结果：2023-07-25 10:10:11

字符串转时间(string —> Time),注意时区问题

// time.Local 指定本地时区
timeStr := "2023-07-25 10:10:11"
t1, _ := time.ParseInLocation("2006-01-02 15:04:05", timeStr, time.Local)   // 2023-07-25 10:10:11 +0800 CST
t2, _ := time.Parse("2006-01-02 15:04:05", timeStr)                         // 2023-07-25 10:10:11 +0000 UTC

3. 文件

1. 解析路径名字符串

4. 字符串

1. 拼接

• strings.join

  // 定义一个字符串数组包含上述的字符串
  var str []string = []string{"hello", "world"}
  // 调用Join函数
  s3 := strings.Join(str, "")

• bytes.Buffer

  // 定义Buffer类型
  var bt bytes.Buffer
  // 向bt中写入字符串
  bt.WriteString("hello")
  bt.WriteString("world")
  // 获得拼接后的字符串
  s3 := bt.String()

• Strings.builder

  var build strings.Builder
  build.WriteString("hello")
  build.WriteString("world")
  s3 := build.String()

5. json 编解码

已知编码解码类型时，可以使用：

解码

• json.Unmarshal([]byte, &v)
• json.NewDecoder(<Reader>).decode(&v)

编码

• json.Marshal(&v)
• json.NewEncoder(<Writer>).encode(v)

未知类型的

interface 接收 json.Unmarshal 的结果，然后把解码结果转换为 map[string]interface{} 类型，进行操作

1. json.Unmarshal

func HandleUse(w http.ResponseWriter, r *http.Request) {
    var u Use //此处的Use是一个结构体
    data, err := ioutil.ReadAll(r.Body)//此处的r是http请求得到的json格式数据-->然后转化为[]byte格式数据.
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        return
    }
    if err := json.Unmarshal(data, &u); err != nil { //经过这一步将json解码赋值给结构体，由json转化为结构体数据
        w.WriteHeader(http.StatusInternalServerError)
        return
    }
    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, "姓名：%s，年龄：%d", u.Name, u.Age)

}

2. json.NewDecoder

json.NewDecoder 是流里直接进行解码，性能较高

func HandleUse(w http.ResponseWriter, r *http.Request) {
    var u Use
    if err := json.NewDecoder(r.Body).Decode(&u); err != nil {
        w.WriteHeader(http.StatusInternalServerError)
        return
    }
    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, "姓名：%s，年龄：%d", u.Name, u.Age)
}

3. 未知类型的

func main() {
    str := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)

    var f interface{}
    json.Unmarshal(str, &f)

    m := f.(map[string]interface{})
    fmt.Println(m["Parents"])  // 读取 json 内容
    fmt.Println(m["a"] == nil) // 判断键是否存在
}