Golang 学习笔记 2-3 复合数据类型引用类型

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

months := [...]string{
    1: "January",
    2:"February",
    3: "March",
    4: "April",
    5: "May",
    6: "June",
    7: "July",
    8: "August",
    9: "September",
    10: "October",
    11: "November",
    12: "December"}
Q2 := months[4:7]
fmt.Println(Q2, cap(Q2))    // `[April May June] 9`
summer := months[6:9]       // `[June July August]`

fmt.Println(summer[:20])    // 宕机, 20 > cap(months)
endlessSummer := summer[:5] // 在 slice 容量范围内扩展了 slice
fmt.Println(endlessSummer)  // `[June July August September October]`

a := [...]int{1, 2, 3, 4, 5, 6, 7}          // 数组
a1 := a[6:]
fmt.Println(a1)                             // `[7]`
fmt.Println(reflect.TypeOf(a1).Kind())      // `slice`

b := "holly shit"                           // 字符串
b1 := b[5:]
fmt.Println(b1)                             // `" shit"`
fmt.Println(reflect.TypeOf(b1).Kind())      // `string`

c := []byte{1,2,3,4,5}                      // 字节 slice
c1 := c[3:]
fmt.Println(c1)                             // `[4 5]`
fmt.Println(reflect.TypeOf(c1).Name())      // `slice`

sa := []string{"a", "b", "c"}
sb := [3]string{"a", "b", "c"}
fmt.Println(reflect.TypeOf(sa), reflect.TypeOf(sa).Kind())
// `[]string slice`
fmt.Println(reflect.TypeOf(sa), reflect.TypeOf(sb).Kind())
// `[3]string array`

make([]T, len)
make([]T, len, cap) // 效果等同于 make([]T, len)[:len]

runes = append(runes, r)

type IntSlice struct{
    ptr         *int
    len,cap     int
}

var x []int
x = append(x, 1)
x = append(x, 1, 2)
x = append(x, 1, 2, 3)
x = append(x, x...) // 追加 x 的所有元素
fmt.Println(x)      // `[1 1 2 1 2 3 1 1 2 1 2 3]`

ages := make(map[string]int) // 创建一个 string 到 int 的 map

ages := map[string]int{
    "alice": 31,
    "charlie": 34,
}
// 上面的写法等价于
ages := make(map[string]int)
ages["alice"] = 31
ages["charlie"] = 34

// 因此，新的空 map 的另一种表达式是
ages := map[string]int{}

delete(ages, "alice") // 移除 ages["alice"]

fmt.Println(ages["bob"] + 1)    // `1`
fmt.Println(ages["bob"])        // `0`
ages["bob"] = ages["bob"] + 1   // 显式地创建了 ages["bob"]
fmt.Println(ages["bob"])        // `1`
// 即使不存在 ages["bob"] 上面的代码也可以执行
// 当键 K 不存在时，键 K 对应的值为 V 类型的零值

_ = &ages["bob"] // 编译错误，无法获取 map 元素的地址

for name, age := range ages {
    fmt.Println("%s\t%d\n", name, age)
}
/* 
bob	    1
alice	31
charlie	34
*/
for name, age := range ages {
    fmt.Println("%s\t%d\n", name, age)
}
/*
alice	31
charlie	34
bob	    1
*/ 

// 两次执行遍历输出，得到了不一样的输出结果。

import "sort"

var names []string
for name := range ages{
    names = append(names, name)
}
sort.Strings(names)
for _, name := range names{
    fmt.Printf("%s\t%d\n", name, ages[name])
}

// 因为一开始就知道 slice names 的长度
// 所以直接指定 slice 的容量会让代码快一些
// var_name := make([]T, len, cap)
names := make([]string, 0, len(ages))

var ages map[string]int     // 仅声明
fmt.Println(ages == nil)    // `true`
fmt.Println(len(ages) == 0) // `true`

ages["carol"] = 21          // 报错，为零值 map 中的项赋值
ages := map[string]int      // 报错，map[string]int is not an expression
ages := map[string]int{}    // 声明并赋值

age, ok := ages["bob"]
if !ok { /* "bob" 不是 map 中的键, age == 0, ok == false */ }

// 通常会将两条语句合并

if age, ok := ages["bob"]; !ok { /* ... */}

type Message struct {
    Name string
    Body string
    Time int64
}
msgs := []Message{
    {"Alice", "Hello", 1294706395881547000},
    {"Bob", "Hi", 1294706395881547009},
}
data, err := json.Marshal(msgs)
if err != nil{
    fmt.Println(err)
}
fmt.Println(data)
fmt.Printf("%s\n", data)
// [91 123 34 78 97 109 101 34 58 34 65 108 105 99 101 34 44 34 66 111 100 121 34 58 34 72 101 108 108 111 34 44 34 84 105 109 101 34 58 49 50 57 52 55 48 54 51 57 53 56 56 49 53 52 55 48 48 48 125 44 123 34 78 97 109 101 34 58 34 66 111 98 34 44 34 66 111 100 121 34 58 34 72 105 34 44 34 84 105 109 101 34 58 49 50 57 52 55 48 54 51 57 53 56 56 49 53 52 55 48 48 57 125 93]
// [{"Name":"Alice","Body":"Hello","Time":1294706395881547000},{"Name":"Bob","Body":"Hi","Time":1294706395881547009}]

data, err := json.MarshalIndent(msgs, "", "    ")
fmt.Printf("%s\n", data)
/*
[
    {
        "Name": "Alice",
        "Body": "Hello",
        "Time": 1294706395881547000
    },
    {
        "Name": "Bob",
        "Body": "Hi",
        "Time": 1294706395881547009
    }
]
*/

type Message struct {
    Name string `json:"msg_name"`
    Body string `json:"msg_body"`
    Time int64 `json:"send_time"`
}
msgs := []Message{
    {"Alice", "Hello", 1294706395881547000},
    {"Bob", "Hi", 1294706395881547009},
}
dataA, err := json.Marshal(msgs)
dataB, err := json.MarshalIndent(msgs, "", "    ")
if err != nil{
    fmt.Println(err)
}
fmt.Printf("%s\n", dataA)
fmt.Printf("%s\n", dataB)
// [{"msg_name":"Alice","msg_body":"Hello","send_time":1294706395881547000},{"msg_name":"Bob","msg_body":"Hi","send_time":1294706395881547009}]
/*
[
    {
        "msg_name": "Alice",
        "msg_body": "Hello",
        "send_time": 1294706395881547000
    },
    {
        "msg_name": "Bob",
        "msg_body": "Hi",
        "send_time": 1294706395881547009
    }
]
*/

msgData := []byte(`[{"msg_name":"Alice","msg_body":"Hello","send_time":1294706395881547000},{"msg_name":"Bob","msg_body":"Hi","send_time":1294706395881547009}]`)
var msgs []Message
if err := json.Unmarshal(msgData, &msgs); err != nil{
    fmt.Println(err)
}
fmt.Println(msgs)
// [{Alice Hello 1294706395881547000} {Bob Hi 1294706395881547009}]

// setting.json
{
    "task": {
        "maxTask": "1000000"
    },
    "redis": {
        "ip": "127.0.0.1",
        "port": "6379",
    }
}

var config map[string]map[string]string
settings, ioReadErr := ioutil.ReadFile("settings.json")
if ioReadErr != nil {
    fmt.Println(ioReadErr)
}
fmt.Println(settings) // seetings 是 []byte
// [123 10 32 32 32 32 34 116 97 115 107 34 58 32 123 10 32 32 32 32 32 32 32 32 34 109 97 120 95 116 97 115 107 34 58 32 34 49 48 48 48 48 48 48 34 10 32 32 32 32 125 44 10 32 32 32 32 34 114 101 100 105 115 34 58 32 123 10 32 32 32 32 32 32 32 32 34 105 112 34 58 32 34 49 50 55 46 48 46 48 46 49 34 44 10 32 32 32 32 32 32 32 32 34 112 111 114 116 34 58 32 34 54 51 55 57 34 10 32 32 32 32 125 10 125]
jsonErr := json.Unmarshal(settings, &config)
if jsonErr != nil {
    fmt.Println(jsonErr)
}
fmt.Println(config)
// map[redis:map[ip:127.0.0.1 port:6379] task:map[max_task:1000000]]