《The.Go.Programming.Language.2015.11.pdf》之数组和切片

4.1数组

数组在go中很少使用，经常用到的是slice，这个后面再讲

数组的声明和初始化

var a [3]int //包含3个整数的数组
var q [3]int = [3]int{1, 2, 3}
var r [3]int = [3]int{1, 2}

//[...]这样的情况，数组长度由初始化的数据个数决定。
q := [...]int{1, 2, 3} //数组长度为3

数组成员的访问

for i, v := range a {
    fmt.Printf("%d %d\n", i, v)
}

对于数组来说，数组长度也是数组类型的一部分，所以[3]int和[4]int是不同的数组类型。

定义常量，通过常量初始化数组

type Currency int
    const (
    USD Currency = iota
    EUR
    GBP
    RMB
)
symbol := [...]string{USD: "$", EUR: "9", GBP: "!", RMB: "￥"}
fmt.Println(RMB, symbol[RMB]) // "3 ￥"

数组的比较

如果数组成员是可以比较的，那么数组也可以比较

a := [2]int{1, 2}
b := [...]int{1, 2}
c := [2]int{1, 3}
fmt.Println(a == b, a == c, b == c) // "true false false"
d := [3]int{1, 2}
fmt.Println(a == d) // compile error: cannot compare [2]int == [3]int

数组作为函数参数

在go语言中，数组作为参数传递，也是按值传递，会复制整个数组过去，非常低效，为了效率，可以传递数组的指针

    func zero(ptr *[32]byte) {
        for i := range ptr {
        ptr[i] = 0
     }
    }

4.2切片

切片表示长度可变的序列，里面的元素都含有相同的类型。切片类型用[]T表示。
切片的主要作用是用来访问数组的子序列。
切片含有三个成员：指针，长度，容量。指针指向数组的一个地址，长度表示切片包含的元素个数，容量表示切片最大可以包含的元素个数。
不同的切片可以指向同一个数组，甚至可以有重叠。

months := [...]string{1: "January", /* ... */, 12: "December"}

切片操作符 s[i:j]，创建一个新的切片指向系列s的元素区间，从第i个到j-1个元素。这个序列s可以是数组，数组指针或者别的序列。如果去掉i，则默认为0，也就是从第一个元素开始，如果去掉j，默认胃len(s)，也就是到最后一个元素。
切片包含指向数组的指针，在函数中可以利用切片在对数组进行修改。

func reverse(s []int) {
    for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
        s[i], s[j] = s[j], s[i]
    }
}

a := [...]int{0, 1, 2, 3, 4, 5}
reverse(a[:])
fmt.Println(a) // "[5 4 3 2 1 0]"

翻转数组可以通过三个逆序操作完成

s := []int{0, 1, 2, 3, 4, 5}
// Rotate s left by two positions.
reverse(s[:2])
reverse(s[2:])
reverse(s)
fmt.Println(s) // "[2 3 4 5 0 1]"

可以通过s := []int{0, 1, 2, 3, 4, 5}生成切片，隐式创建一个合理长度的数组，然后创建切片指向它。
切片是不可比较的。

go语言中map类型的key需要值在整个生命周期中保持不变，但是切片不变，指向的数组也可能改变，所以切片不能够作为key。
nil切片的长度和容量都为0，但是也存在非nil长度和容量为0的切片[]int{} 或make([]int, 3)[3:]

append函数

    var runes []rune
    for _, r := range "Hello, 世界" {
        runes = append(runes, r)
    }
    fmt.Printf("%q\n", runes) // "['H' 'e' 'l' 'l' 'o' ',' ' ' '世' '界'] "

append函数在当前容量不够的情况下，会申请2倍于之前的容量，把原来数据复制过去再添加。

利用append实现特殊函数

func remove(slice []int, i int) []int {
    copy(slice[i:], slice[i+1:])
    return slice[:len(slice)-1]
}
func main() {
    s := []int{5, 6, 7, 8, 9}
    fmt.Println(remove(s, 2)) // "[5 6 8 9]"
}

不保存顺序

//d if we don’t need to preserve the order, we can just move the last element into the gap:
func remove(slice []int, i int) []int {
    slice[i] = slice[len(slice)-1]
    return slice[:len(slice)-1]
}
func main() {
    s := []int{5, 6, 7, 8, 9}
    fmt.Println(remove(s, 2)) // "[5 6 9 8]
}