排序
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]]