go001

01 时间转换

func main() {
    layout := "2006-01-02 15:04:05"

    // 获取当前时间 time.Time
    t := time.Now()

    // time.Time转string
    tStr := t.Format(layout)

    // time.Time转时间戳
    tStamp := t.Unix()

    // 时间戳转转time.Time
    tt := time.Unix(tStamp, 0)

    // 时间戳转string
    ts := time.Unix(tStamp, 0).Format(layout)

    fmt.Printf("t: %v\n", t)
    fmt.Printf("tStr: %v\n", tStr)
    fmt.Printf("tStamp: %v\n", tStamp)
    fmt.Printf("tt: %v\n", tt)
    fmt.Printf("ts: %v\n", ts)
}

输出

t: 2019-04-23 13:58:43.032685 +0800 CST m=+0.000233275
tStr: 2019-04-23 13:58:43
tStamp: 1555999123
tt: 2019-04-23 13:58:43 +0800 CST
ts: 2019-04-23 13:58:43

02 字符串和数字转换

func main() {
    str := "123"
    it := 456

    // string转int
    _, err := strconv.Atoi(str)
    
    // string转int64
    _, err = strconv.ParseInt(str, 10, 64)

    // int转string
    _ = strconv.Itoa(it)

    // int64转string
    _ = strconv.FormatInt(int64(it), 10)
}

03 序列化操作

package main

import (
    "encoding/json"
    "fmt"
)

// 序列化struct
func serializeStruct() {
    type User struct {
        Name  string `json:"name"`
        Age   int    `json:age`
        Email string
    }

    user := User{
        Name:  "cy",
        Age:   28,
        Email: "cy@163.com",
    }

    data, err := json.Marshal(&user) // 注意传入的是struct变量地址
    if err != nil {
        fmt.Printf("json.marshal failed, err:%s", err)
    }
    fmt.Println(string(data))
}

// 序列化slice
func serializeSlice() {
    var s []map[string]interface{}
    m1 := make(map[string]interface{})
    m1["username"] = "cy"
    m1["age"] = 18
    m2 := make(map[string]interface{})
    m2["username"] = "coder"
    m2["age"] = 28
    s = append(s, m1, m2)
    data, err := json.Marshal(s)
    if err != nil {
        fmt.Printf("json.marshal failed,err:", err)
        return
    }
    fmt.Println(string(data))

    l := []int{12, 34, 56}
    d, _ := json.Marshal(l)
    fmt.Println(string(d))
}

// 序列化map
func serializeMap() {
    var m map[string]interface{}
    m = make(map[string]interface{})
    m["name"] = "cy"
    m["age"] = 18
    data, err := json.Marshal(m)
    if err != nil {
        fmt.Printf("json.marshal failed,err:", err)
        return
    }
    fmt.Println(string(data))
}

// 序列化int
func serializeInt() {
    var a = 18
    data, err := json.Marshal(a)
    if err != nil {
        fmt.Printf("json.marshal failed,err:", err)
        return
    }
    fmt.Println(string(data))
}

func main() {
    serializeStruct()
    serializeSlice()
    serializeMap()
    serializeInt()
}

输出

{"name":"cy","Age":28,"Email":"cy@163.com"}
[{"age":18,"username":"cy"},{"age":28,"username":"coder"}]
[12,34,56]
{"age":18,"name":"cy"}
18

04 修改字符串

要修改字符串，可先转成[]rune或[]byte，修改完再转回string。无论哪种转换都会重新分配内存，并复制字节数组。

func main() {
    s := "abcd"
    bs := []byte(s)
    bs[1] = 'B'
    fmt.Println(string(bs))

    u := "电脑"
    us := []rune(u)
    us[1] = '话'
    fmt.Println(string(us))
}

输出

aBcd
电话

for循环遍历字符串时，也有byte和rune两种方式。

func main() {
    s := "abc汉字"
    
    for i:= 0; i<len(s); i++ {  // byte
        fmt.Printf("%c ", s[i])
    }
    fmt.Println()

    for _, r := range s {  // rune
        fmt.Printf("%c ", r)
    }
}

输出

a b c æ ±  å ­  
a b c 汉 字

05 range复制问题

func main() {
    // 引用类型，底层数据不会被复制
    a := []int{0, 1, 2}
    for i, v := range a {
        fmt.Println(i, v)
        if i == 0 {
            a[1], a[2] = 999, 999
            fmt.Println(a)
        }

        a[i] = v + 100
    }
    fmt.Println(a)
    fmt.Println()
    // 引用类型，底层数据不会被复制
    b := map[int]int{0:0,1:1,2:2}
    for i, v := range b {
        fmt.Println(i, v)
        if i == 0 {
            b[1], b[2] = 999, 999
            fmt.Println(b)
        }

        b[i] = v + 100
    }
    fmt.Println(b)
    fmt.Println()
    // 数组类型，range会复制对象
    c := [3]int{0, 1, 2}
    for i, v := range c {  // i，v都是从复制品中取出
        fmt.Println(i, v)
        if i == 0 {
            c[1], c[2] = 999, 999
            fmt.Println(c)
        }

        c[i] = v + 100 // 使用复制品取出的v修改数组
    }
    fmt.Println(c)
}

输出

0 0
[0 999 999]
1 999
2 999
[100 1099 1099]

0 0
map[0:0 1:999 2:999]
1 999
2 999
map[0:100 1:1099 2:1099]

0 0
[0 999 999]
1 1
2 2
[100 101 102]

06 时间戳

fmt.Printf("时间戳（秒）：%v;\n", time.Now().Unix()) // 10位
fmt.Printf("时间戳（纳秒）：%v;\n", time.Now().UnixNano())
fmt.Printf("时间戳（毫秒）：%v;\n", time.Now().UnixNano()/1e6) // 13位
fmt.Printf("时间戳（纳秒转换为秒）：%v;\n", time.Now().UnixNano()/1e9)

07 带nil的初始化

b := []byte(nil) // 等价var bb []byte
b = []byte("bcv")
s := (*string)(nil) // 等价 var cc *string
tmp := "hello"
s = &tmp

fmt.Println(b, *s)