2 - 常用集合

数组

• Go 中的数组和其他语言数组的初始化类似
• 你必须指定数组的长度，你可以用 ... 代替这个长度
• 你可以用 range 遍历数组
• Go 的数组支持截取

package Array_test

import "testing"

func TestArrayInit(t *testing.T)  {
    var arr [3]int // [0, 0, 0]
    var arr2 = [...]int{1,2,3}  // 如果你懒得看长度有多少，可以直接使用 ...
    //var arr3 = [...]int{1,2,3 }
    arr3 := arr2
    arr3[0] = 9
    t.Log(arr, arr2, arr3)

}

func TestArrayTravel(t *testing.T){
    var arr = [...]int{1,2,3}
    for i := 0 ; i < len(arr) ; i++{
        t.Log(arr[i])
    }
    for _, v := range arr{  // _ 为索引值，使用 _ 用于占位
        t.Log(v)
    }
}

func TestArraySection(t *testing.T){
    var arr = [...]int{1, 2, 3, 4, 5}
    arr2 := arr[3:]
    for _, v := range arr2{
        t.Log(v)
    }
    arr2[0] = 6
    t.Log(arr[3], arr2[0])  // 你会发现，它们的内容是共享的
}

• 注意：使用 == 比较数组会有维数和个数的限制

切片

• 你可以将切片当作一个可以自动伸缩的数组
• 使用 len函数 可以查看长度，使用 cap函数 可以查看容量
• 容量不足时会自动扩容，扩容策略：小于 1024 时翻倍，大于时扩容四分之一

package slice_test

import "testing"

func TestSlice(t *testing.T){
    var s = []int{}
    for i := 0; i < 10; i++{
        s = append(s, i)
        t.Log(s, len(s), cap(s))
    }

    var s2 = make([]int, 3, 5)
    t.Log(len(s2), cap(s2))  // 3, 5
}

• 注意：使用 == 无法比较两个切片

map

• 使用 range 遍历
• 如果一个元素不存在，Go 会返回一个空值（int 的话为 0）
• 所以，你要区分这种情况，就需要额外使用一些代码

package ch7

import "testing"

func TestMap(t *testing.T)  {
    m1 := map[string]int{"one":1, "two":2}
    m2 := map[string]int{}
    m3 := make(map[string]int, 10)
    t.Log(m1, len(m1))
    t.Log(m2, len(m2))
    t.Log(m3, len(m2))

    for k, v := range m1{  // 遍历的方法
        t.Log(k, v)
    }

    if v, ok := m2["three"] ; ok{  // ok 为 bool 值，用于判断 key 是否存在。
        t.Log("exist", v)
    }else {
        t.Log("not exist", v) // no exist 0
    }
}

• map 的 value 可以为函数，使用这种方法可以实现工厂模式

package map_ext

import "testing"

func TestMapWithFunc(t *testing.T)  {
    m := map[int]func(op int) int{}  // 创建一个 map，key 为 int， value 为 func；func 的输入为 int，返回值为 int
    m[1] = func(op int) int {
        return op
    }
    m[2] = func(op int) int {
        return op * op
    }
    m[3] = func(op int) int {
        return op * op * op
    }
    t.Log(m[1](2), m[2](2), m[3](2))  // 2,4,8
}

• Go 中没有 set 类型，你可以用 map 变形为 set

func TestMapForSet(t *testing.T){
    mySet := map[int]bool{}
    mySet[1] = true
    mySet[2] = true

    if mySet[1]{
        t.Log("1 is existing")  // 执行
    }else {
        t.Log("1 is not existing")
    }

    t.Log(len(mySet))  // 2
    delete(mySet, 1)  // 删除
}

字符串

• Go 中的字符串为数据类型，而非指针或引用
• string 是只读的
• len 得到的是字节数，而非字符数
• string 是一个 byte 数组，可以存放任意内容的二进制数据

package strin

import "testing"

func TestString(t *testing.T){
    var s string
    t.Log(s)
    s = "hello"
    t.Log(s, len(s))  // hello,5
    s = "\xE4\xB8\xA5"  // \x代表后面的两个字符为十六进制数据，也就是一个字节的数据量
    t.Log(s, len(s))  // 严，3
    s = "中"
    t.Log(s, len(s))  // 中，3

    c := []rune(s)  // 取 unicode
    t.Log(len(c))  // 1
    t.Logf("中 的 unicode：%x", c[0])  // 输出 中 在unicode 里的编码
    t.Logf("中 的 UTF8: %x", s)  // 输出 中 在UTF8 里的编码

}

• 即使 Go 的 string 以字节为单位，但是你不必担心它的遍历会出问题：

func TestStringToRune(t *testing.T){
    s := "早睡早起"
    for _, c := range s{
        t.Logf("%[1]c %[1]x", c)  // 输出 c 的 unicode 编码，以及 c 的 十六进制编码
    }
}

• strings 包：包含了常用的字符串操作
• strconv 包：包含了字符串转换操作