排序

Golang 提供 sort package 来实现排序。
例如 func Ints(x []int) 来排序 int 的 slice：

s := []int{5, 2, 6, 3, 1, 4} // unsorted
sort.Ints(s)
fmt.Println(s) // [1 2 3 4 5 6]

例如 func Strings(x []string) 来排序 string 的 slice：

s := []string{"Go", "Bravo", "Gopher", "Alpha", "Grin", "Delta"}
sort.Strings(s)
fmt.Println(s) // [Alpha Bravo Delta Go Gopher Grin]

例如 func Slice(x interface{}, less func(i, j int) bool) 来排序结构体 struct 的 slice：

type People struct {
    Name string
    Age int
}
people := []People {
    {"Gopher", 7},
    {"Alice", 55},
    {"Vera", 24},
    {"Bob", 75},
}
sort.Slice(people, func(i, j int) bool { return people[i].Name < people[j].Name })
fmt.Println("By name:", people) // By name: [{Alice 55} {Bob 75} {Gopher 7} {Vera 24}]

sort.Slice(people, func(i, j int) bool { return people[i].Age < people[j].Age })
fmt.Println("By age:", people) // By age: [{Gopher 7} {Vera 24} {Alice 55} {Bob 75}]

类型转换

Golang 没有 double，可以使用 float32 和 float64。

byte 转 int 的操作：

b := '9'
var i int
i = int(b - '0')
fmt.Println(i) // 9

遍历

遍历 string 的每一个 byte：

str := "abc"
// 方式一
for idx, b := range str {
    fmt.Printf("%d: %c\n", idx, b)
}
// 方式二
for idx := 0; idx < len(str); idx++ {
    fmt.Printf("%d: %c\n", idx, str[idx])
}

遍历 slice 需要接收两个返回值：

nums := []int {4, 5, 6}
    
for _, num := range nums {
    fmt.Println(num) // 4, 5, 6
}

// 下面这段实际得到的是 index
for num := range nums {
    fmt.Println(num) // 0, 1, 2
}

值传递 Vs. 引用传递

基本数据类型和 array，slice 以及结构体 struct 等都是值传递：

func main() {
    i := 1
    arr := []int{2, 3}
    
    fmt.Println(i) // 1
    fmt.Println(arr) // [2 3]
    f(i, arr)
    fmt.Println(i) // 1 没有变化
    fmt.Println(arr) // [2 3] 没有变化
}

func f(i int, arr []int) {
    i = 2
    arr[0] = 4
    arr[1] = 5
}

如果想要在函数中修改 slice 的值，则需要传递 slice 的指针：

func main() {
    arr := []int{2, 3}
    
    fmt.Println(arr) // [2 3]
    f(&arr)
    fmt.Println(arr) // [4 5] 有变化
}

func f(arr *[]int) {
    (*arr)[0] = 4
    (*arr)[1] = 5
}

To be specific, Go does not support “Pass-By-Reference” semantic in any way. Go 不支持引用传递

但是我们发现如果传递 map 的话，则值会在函数中被修改：

func main() {
    m := make(map[string]int)
    m["A"] = 1
    m["B"] = 2
    
    fmt.Println(m) // [A:1 B:2]
    f(m)
    fmt.Println(m) // [A:3 B:4] 有变化
}

func f(m map[string]int) {
    m["A"] = 3
    m["B"] = 4
}

这是因为在使用 make() 创建 map 时实际返回的是一个指针 *hmap，所以传入函数的也是一个指针。

通过 Slice 来实现 Queue 和 Stack

实现 Queue：

var queue []string

queue = append(queue, "Hello ") // Enqueue
queue = append(queue, "world!")

for len(queue) > 0 {
    fmt.Print(queue[0]) // First element
    queue = queue[1:]   // Dequeue
}

实现 Stack：

var stack []string

stack = append(stack, "Hello ") // Push to stack
stack = append(stack, "world!")

for len(stack) > 0 {
    n := len(stack) - 1
    fmt.Print(stack[n]) // Last element
    stack = stack[:n]   // Dequeue
}

map 的一些操作

map 有两种方式初始化：

m1 := make(map[string]int)
m1["A"] = 1
fmt.Println(m1) // [A:1]

m2 := map[string]int {}
m2["B"] = 2
fmt.Println(m2) // [B:2]

map 如果不初始化的话，则为一个 nil 指针，可以 read，但是不能 write：

var m map[string]int
fmt.Println(m["A"]) // 0 默认值

m["A"] = 1 // panic: assignment to entry in nil map

如果 map 里面不包含对应的 key 的话，则 m[key] 会返回一个默认值，根据 value 的类型，这个默认值可能是 0，false，nil，因此有时候实际上不需要检测 key 是否存在：

m1 := make(map[string]int)
fmt.Println(m1["A"]) // 0 默认值

m2 := map[string]string {}
fmt.Println(m2["B"]) // empty string 默认值

可以使用 len(m) 得到 map 中元素的数目，可以使用 delete(m, "A") 来删除 map 中某个 key。

map 不保证 Concurrency，可以结合 sync.RWMutex 来实现同步，具体参见 https://golang.org/pkg/sync/

map 不保证遍历顺序，因此 for k, v := range m 不能保证每次都一样的顺序。

二维数组和 slice 的初始化

a1 := [2][2]int{}
a1[1][1] = 5
fmt.Println(a1) // [[0 0] [0 5]]

a2 := [][]int{}
a2 = append(a2, []int{1, 2, 3})
a2 = append(a2, []int{4, 5, 6})
fmt.Println(a2) // [[1 2 3] [4 5 6]]

a3 := make([][]int, 2)
for i := 0; i < 2; i++ {
    a3[i] = make([]int, 3)
}
fmt.Println(a3) // [[0 0 0] [0 0 0]]