数组、切片和映射

在严格意义上，Go中有三种一等公民容器类型：数组、切片和映射。有时候，我们可以认为字符串类型和通道类型也属于容器类型。但是，此篇文章只谈及数组、切片和映射类型。

Go中有很多和容器类型相关的细节，本文将逐一列出这些细节。

容器类型和容器值概述

每个容器（值）用来表示和存储一个元素（element）序列或集合。一个容器中的所有元素的类型是相同的。此相同的类型称为此容器的类型的元素类型（或简称此容器的元素类型）。

存储在一个容器中的每个元素值都关联着着一个键值（key）。每个元素可以通过它的键值而被访问到。一个映射类型的键值类型必须为一个可比较类型。数组和切片类型的键值类型均为内置类型int。一个数组或切片的一个元素对应的键值总是一个非负整数下标，此非负整数表示该元素在该数组或切片所有元素中的顺序位置。此非负整数下标亦常称为一个元素索引（index）。

每个容器值有一个长度属性，用来表明此容器中当前存储了多少个元素。一个数组或切片中的每个元素所关联的非负整数索引键值的合法取值范围为左闭右开区间[0, 此数组或切片的长度)。一个映射值类型的容器值中的元素关联的键值可以是任何此映射类型的键值类型的任何值。

这三种容器类型的值在使用上有很多的差别。这些差别多源于它们的内存定义的差异。通过上一篇文章值部，我们得知每个数组值仅由一个直接部分组成，而一个切片或者映射值是由一个直接部分和一个可能的被此直接部分引用着的间接部分组成。

一个数组或者切片的所有元素紧挨着存放在一块连续的内存中。一个数组中的所有元素均存放在此数组值的直接部分，一个切片中的所元素均存放在此切片值的间接部分。在官方标准编译器和运行时中，映射是使用哈希表算法来实现的。所以一个映射中的所有元素也均存放在一块连续的内存中，但是映射中的元素并不一定紧挨着存放。另外一种常用的映射实现算法是二叉树算法。无论使用何种算法，一个映射中的所有元素的键值也存放在此映射值（的间接部分）中。 我们可以通过一个元素的键值来访问此元素。对于这三种容器，元素访问的时间复杂度均为O(1)。但是一般来说，映射元素访问消耗的时长要数倍于数组和切片元素访问消耗的时长。但是映射相对于数组和切片有两个优点：

• 映射的键值类型可以是任何可比较类型。
• 相对于使用含有大量稀疏索引的数组和切片，使用映射可以节省大量的内存。 从上一篇文章中，我们已经了解到，在任何赋值中，源值的底层间接部分不会被复制。换句话说，当一个赋值结束后，一个含有间接部分的源值将和目标值将共享底层间接部分。这是为什么数组和切片/映射值会有很多行为差异（将在下面逐一介绍）的原因。

非定义容器类型的字面表示形式

非定义容器类型的字面表示形式如下：

• 数组类型：[N]T
• 切片类型：[]T
• 映射类型：map[K]T其中，
• T可为任意类型。它表示一个容器类型的元素类型。某个特定容器类型的值中只能存储此容器类型的元素类型的值。
• N必须为一个非负整数常量。它指定了一个数组类型的长度，或者说它指定了此数组类型的任何一个值中存储了多少个元素。一个数组类型的长度是此数组类型的一部分。比如[5]int和[8]int是两个不同的类型。
• K必须为一个可比较类型。它指定了一个映射类型的键值类型。下面列出了一些非定义容器类型的字面表示：

const Size = 32
type Person struct {
    name string
    age  int
}
// 数组类型
[5]string
[Size]int
[16][]byte  // 元素类型为一个切片类型：[]byte
[100]Person // 元素类型为一个结构体类型：Person
// 切片类型
[]bool
[]int64
[]map[int]bool // 元素类型为一个映射类型：map[int]bool
[]*int         // 元素类型为一个指针类型：*int
// 映射类型
map[string]int
map[int]bool
map[int16][6]string     // 元素类型为一个数组类型：[6]string
map[bool][]string       // 元素类型为一个切片类型：[]string
map[struct{x int}]*int8 // 元素类型为一个指针类型：*int8；
                        // 键值类型为一个结构体类型。

所有切片类型的尺寸都是一致的，所有映射类型的尺寸也都是一致的。一个数组类型的尺寸等于它的元素类型的尺寸和它的长度的乘积。长度为零的数组的尺寸为零；元素类型尺寸为零的任意长度的数组类型的尺寸也为零。

容器类型值的字面表示形式

和结构体值类似，容器值的文字表示也可以用组合字面值（composite literal）来表示。比如对于一个容器类型T，它的值可以用形式T{…}来表示（除了切片和映射的零值外）。下面是一些结构体值的字面表示形式：

// 一个含有4个布尔元素的数组值。
[4]bool{false, true, true, false}
// 一个含有三个字符串值的切片值。
[]string{"break", "continue", "fallthrough"}
// 一个映射值。
map[string]int{"C": 1972, "Python": 1991, "Go": 2009}

映射组合字面值中大括号中的每一项称为一个键值对（key-value pair），或者称为一个条目（entry）。 数组和切片组合字面值有一些微小的变种：

// 下面这些切片的字面表示形式都是等价的。
[]string{"break", "continue", "fallthrough"}
[]string{0: "break", 1: "continue", 2: "fallthrough"}
[]string{2: "fallthrough", 1: "continue", 0: "break"}
[]string{2: "fallthrough", 0: "break", "continue"}
// 下面这些数组的字面表示形式都是等价的。
[4]bool{false, true, true, false}
[4]bool{0: false, 1: true, 2: true, 3: false}
[4]bool{1: true, true}
[4]bool{2: true, 1: true}
[...]bool{false, true, true, false}
[...]bool{3: false, 1: true, true}

上例中最后两行中的…表示让编译器推断出相应数组值的类型的长度。 从上面的例子中，我们可以看出数组和切片组合字面值中的索引下标（即数组和切片的键值）是可选的。在一个数组或者切片组合字面值中：

• 如果一个索引下标出现，它的类型不必是数组和切片类型的键值类型int，但它必须是一个可以表示为int值的非负常量；如果它是一个类型确定值，则它的类型必须为一个基本整数类型。
• 在一个数组和切片组合字面值中，如果一个元素的索引下标缺失，则编译器认为它的索引下标为出现在它之前的元素的索引下标加一。
• 如果出现的第一个元素的索引下标缺失，则它的索引下标被认为是0。 映射组合字面值中元素对应的键值不可缺失，并且它们可以为非常量。

var a uint = 1
var _ = map[uint]int {a : 123} // 没问题
var _ = []int{a: 100}          // error: 下标必须为常量
var _ = [5]int{a: 100}         // error: 下标必须为常量

一个容器组合字面值中的常量键值（包括索引下标）不可重复。

容器类型零值的字面表示形式

和结构体类似，一个数组类型A的零值可以表示为A{}。比如，数组类型[100]int的零值可以表示为[100]int{}。一个数组零值中的所有元素均为对应数组元素类型的零值。

和指针一样，所有切片和映射类型的零值均用预声明的标识符nil来表示。

顺便说一句，除了刚提到的三种类型，以后将介绍的函数、通道和接口类型的零值也用预声明的标识符nil来表示。

在运行时刻，即使一个数组变量在声明的时候未指定初始值，它的元素所占的内存空间也已经被开辟出来。但是一个nil切片或者映射值的元素的内存空间尚未被开辟出来。

注意：[]T{}表示类型[]T的一个空切片值，它和[]T(nil)是不等价的。同样，map[K]T{}和map[K]T(nil)也是不等价的。

容器字面值是不可寻址的但可以被取地址

我们已经了解到结构体（组合）字面值是不可寻址的但却是可以被取地址的。容器字面值也不例外。 一个例子：

package main
import "fmt"
func main() {
    pm := &map[string]int{"C": 1972, "Go": 2009}
    ps := &[]string{"break", "continue"}
    pa := &[...]bool{false, true, true, false}
    fmt.Printf("%T\n", pm) // *map[string]int
    fmt.Printf("%T\n", ps) // *[]string
    fmt.Printf("%T\n", pa) // *[4]bool
}

内嵌组合字面值可以被简化

在某些情形下，内嵌在其它组合字面值中的组合字面值可以简化为{…}（即类型部分被省略掉了）。内嵌组合字面值前的取地址操作符&有时也可以被省略。 比如，下面的组合字面值

// heads为一个切片值。它的类型的元素类型为*[4]byte。
// 此元素类型为一个基类型为[4]byte的指针类型。
// 此指针基类型为一个元素类型为byte的数组类型。
var heads = []*[4]byte{
    &[4]byte{'P', 'N', 'G', ' '},
    &[4]byte{'G', 'I', 'F', ' '},
    &[4]byte{'J', 'P', 'E', 'G'},
}

可以被简化为

var heads = []*[4]byte{
    {'P', 'N', 'G', ' '},
    {'G', 'I', 'F', ' '},
    {'J', 'P', 'E', 'G'},
}

下面这个数组组合字面值

type language struct {
    name string
    year int
}
var _ = [...]language{
    language{"C", 1972},
    language{"Python", 1991},
    language{"Go", 2009},
}

可以被简化为

var _ = [...]language{
    {"C", 1972},
    {"Python", 1991},
    {"Go", 2009},
}

下面这个映射组合字面值

type LangCategory struct {
    dynamic bool
    strong  bool
}
// 此映射值的类型的键值类型为一个结构体类型，
// 元素类型为另一个映射类型：map[string]int。
var _ = map[LangCategory]map[string]int{
    LangCategory{true, true}: map[string]int{
        "Python": 1991,
        "Erlang": 1986,
    },
    LangCategory{true, false}: map[string]int{
        "JavaScript": 1995,
    },
    LangCategory{false, true}: map[string]int{
        "Go":   2009,
        "Rust": 2010,
    },
    LangCategory{false, false}: map[string]int{
        "C": 1972,
    },
}

可以被简化为

var _ = map[LangCategory]map[string]int{
    {true, true}: {
        "Python": 1991,
        "Erlang": 1986,
    },
    {true, false}: {
        "JavaScript": 1995,
    },
    {false, true}: {
        "Go":   2009,
        "Rust": 2010,
    },
    {false, false}: {
        "C": 1972,
    },
}

注意，在上面的几个例子中，最后一个元素后的逗号不能被省略。原因详见后面的断行规则一文。

容器值的比较

在Go类型系统概述一文中，我们已经了解到映射和切片类型都属于不可比较类型。所以任意两个映射值（或切片值）是不能相互比较的。

尽管两个映射值和切片值是不能比较的，但是一个映射值或者切片值可以和预声明的nil标识符进行比较以检查此映射值或者切片值是否为一个零值。

大多数数组类型都是可比较类型，除了元素类型为不可比较类型的数组类型。

当比较两个数组值时，它么的对应元素将逐一被比较。这两个数组只有在它们的对应元素都相等的情况下才相等。

一个例子：

package main
import "fmt"
func main() {
    var a [16]byte
    var s []int
    var m map[string]int
    fmt.Println(a == a)   // true
    fmt.Println(m == nil) // true
    fmt.Println(s == nil) // true
    fmt.Println(nil == map[string]int{}) // false
    fmt.Println(nil == []int{})          // false
    // 下面这些行编译不通过。
    /*
    _ = m == m
    _ = s == s
    _ = m == map[string]int(nil)
    _ = s == []int(nil)
    var x [16][]int
    _ = x == x
    var y [16]map[int]bool
    _ = y == y
    */
}

查看容器值的长度和容量

除了上面已提到的容器长度属性（此容器中含有有多少个元素），每个容器值还有一个容量属性。一个数组值的容量总是和它的长度相等；一个非零映射值的容量可以被认为是无限大的。切片值的容量的含义将在后续章节介绍。一个切片值的容量总是不小于此切片值的长度。在编程中，只有切片值的容量有实际意义。

我们可以调用内置函数len来获取一个容器值的长度，或者调用内置函数cap来获取一个容器值的容量。这两个函数都返回一个int类型确定结果值（此返回值可能会在以后的某个Go版本中改为一个类型非确定整数值）。因为非零映射值的容量是无限大，所以cap并不适用于映射值。

一个数组值的长度和容量永不改变。同一个数组类型的所有值的长度和容量都总是和此数组类型的长度相等。切片值的长度和容量可在运行时刻改变。因为此原因，切片可以被认为是动态数组。切片在使用上相比数组更为灵活，所以切片（相对数组）在编程用得更为广泛。

一个例子：

package main
import "fmt"
func main() {
    var a [5]int
    fmt.Println(len(a), cap(a)) // 5 5
    var s []int
    fmt.Println(len(s), cap(s)) // 0 0
    s, s2 := []int{2, 3, 5}, []bool{}
    fmt.Println(len(s), cap(s), len(s2), cap(s2)) // 3 3 0 0
    var m map[int]bool
    fmt.Println(len(m)) // 0
    m, m2 := map[int]bool{1: true, 0: false}, map[int]int{}
    fmt.Println(len(m), len(m2)) // 2 0
}

上面这个特定的例子中的每个切片值的长度和容量都相等，但这并不是一个普遍定律。我们将在后面的章节中展示一些长度和容量不相等的切片值。

读取和修改容器的元素

一个容器值v中存储的对应着键值k的元素用语法形式v[k]来表示。今后我们称v[k]为一个元素索引表达式。 假设v是一个数组或者切片，在v[k]中，

• 如果k是一个常量，则它必须满足上面列出的对出现在组合字面值中的索引的要求。另外，如果v是一个数组，则k必须小于此数组的长度。
• 如果k不是一个常量，则它必须为一个整数。另外它必须为一个非负数并且小于len(v)，否则，在运行时刻将产生一个恐慌。
• 如果v是一个零值切片，则在运行时刻将产生一个恐慌。假设v是一个映射值，在v[k]中，k的类型必须为（或者可以隐式转换为）v的类型的元素类型。另外，
• 如果k是一个动态类型为不可比较类型的接口值，则v[k]在运行时刻将造成一个恐慌；
• 如果v[k]被用做一个赋值语句中的目标值并且v是一个零值nil映射，则v[k]在运行时刻将造成一个恐慌；
• 如果v[k]用来表示读取映射值v中键值k对应的元素，则它无论如何都不会产生一个恐慌，即使v是一个零值nil映射（假设k的估值没有造成恐慌）；
• 如果v[k]用来表示读取映射值v中键值k对应的元素，并且映射值v中并不含有对应着键值k的条目，则v[k]返回一个此映射值的类型的元素类型的零值。一般情况下，v[k]被认为是一个单值表达式。但是在一个v[k]被用为唯一源值的赋值语句中，v[k]可以返回一个可选的第二个返回值。此第二个返回值是一个类型不确定布尔值，用来表示是否有对应着键值k的条目存储在映射值v中。一个展示了容器元素修改和读取的例子：

package main
import "fmt"
func main() {
    a := [3]int{-1, 0, 1}
    s := []bool{true, false}
    m := map[string]int{"abc": 123, "xyz": 789}
    fmt.Println (a[2], s[1], m["abc"])    // 读取
    a[2], s[1], m["abc"] = 999, true, 567 // 修改
    fmt.Println (a[2], s[1], m["abc"])    // 读取
    n, present := m["hello"]
    fmt.Println(n, present, m["hello"]) // 0 false 0
    n, present = m["abc"]
    fmt.Println(n, present, m["abc"]) // 567 true 567
    m = nil
    fmt.Println(m["abc"]) // 0
    // 下面这两行编译不同过。
    /*
    _ = a[3]  // 下标越界
    _ = s[-1] // 下标越界
    */
    // 下面这几行每行都会造成一个恐慌。
    _ = a[n]         // panic: 下标越界
    _ = s[n]         // panic: 下标越界
    m["hello"] = 555 // panic: m为一个零值映射
}

重温一下切片的内部结构

为了更好的理解和解释切片类型和切片值，我们最好对切片的内部结构有一个基本的印象。在上一篇文章值部中，我们已经了解到官方标准编译器对切片类型的内部定义大致如下：

type _slice struct {
    elements unsafe.Pointer // 引用着底层存储在间接部分上的元素
    len      int            // 长度
    cap      int            // 容量
}

虽然其它编译器中切片类型的内部结构可能并不完全和官方标准编译器一致，但应该大体上是相似的。下面的解释均基于官方标准编译器对切片类型的内部定义。

上面展示的切片的内部定义为切片的直接部分的定义。直接部分的len字段表示一个切片当前存储了多少个元素；直接部分的cap表示一个切片的容量。下面这张图描绘了一个切片值的内存布局。

尽管一个切片值的底层元素部分可能位于一个比较大的内存片段上，但是此切片值只能感知到此内存片段上的一个子片段。比如，上图中的切片值只能感知到灰色的子片段。

在上图中，从下标len（包含）到下标cap（不包含）对应的元素并不属于图中所示的切片值。它们只是此切片之中的一些冗余元素槽位，但是它们可能是其它切片（或者数组）值中的有效元素。

下一节将要介绍如何通过调用内置append函数来向一个基础切片添加元素而得到一个新的切片。这个新的结果切片可能和这个基础切片共享起始元素，也可能不共享，具体取决于基础切片的容量（以及长度）和添加的元素数量。 当一个切片被用做一个append函数调用中的基础切片，

• 如果添加的元素数量大于此（基础）切片的冗余元素槽位的数量，则一个新的底层内存片段将被开辟出来并用来存放结果切片的元素。这时，基础切片和结果切片不共享任何底层元素。
• 否则，不会有底层内存片段被开辟出来。这时，基础切片中的所有元素也同时属于结果切片。两个切片的元素都存放于同一个内存片段上。 下下一节将展示一张包含了上述两种情况的图片。

一些其它切片操作也可能会造成两个切片共享底层内存片段的情况。这些操作将在后续章节逐一介绍。

注意，一般我们不能单独单独修改一个切片值的某个内部字段，除非使用反射或者非类型安全指针。换句话说，一般我们只能通过将其它切片赋值给一个切片来同时修改这个切片的三个字段。

容器赋值

当一个映射赋值语句执行完毕之后，目标映射值和源映射值将共享底层的元素。向其中一个映射中添加（或从一个映射中删除）元素将体现在另一个映射中。

和映射一样，当一个切片赋值给另一个切片后，它们将共享底层的元素。它们的长度和容量也相等。但是如果以后其中一个切片改变了长度或者容量，此变化不会影响到另一个切片。

当一个数组被赋值给另一个数组，所有的元素都将被从源数组复制到目标数组。赋值完成之后，这两个数组不共享任何元素。 一个例子：

package main
import "fmt"
func main() {
    m0 := map[int]int{0:7, 1:8, 2:9}
    m1 := m0
    m1[0] = 2
    fmt.Println(m0, m1) // map[0:2 1:8 2:9] map[0:2 1:8 2:9]
    s0 := []int{7, 8, 9}
    s1 := s0
    s1[0] = 2
    fmt.Println(s0, s1) // [2 8 9] [2 8 9]
    a0 := [...]int{7, 8, 9}
    a1 := a0
    a1[0] = 2
    fmt.Println(a0, a1) // [7 8 9] [2 8 9]
}

添加和删除容器元素

向一个映射中添加一个条目的语法和修改一个映射元素的语法是一样的。比如，对于一个非零映射值m，如果当前m中尚未存储条目(k, e)，则下面的语法形式将把此条目存入m；否则，下面的语法形式将把键值k对应的元素值更新为e。

m[k] = e

delete(m, k)

package main
import "fmt"
func main() {
    m := map[string]int{"Go": 2007}
    m["C"] = 1972     // 添加
    m["Java"] = 1995  // 添加
    fmt.Println(m)    // map[C:1972 Go:2007 Java:1995]
    m["Go"] = 2009    // 修改
    delete(m, "Java") // 删除
    fmt.Println(m)    // map[C:1972 Go:2009]
}

package main
import "fmt"
func main() {
    s0 := []int{2, 3, 5}
    fmt.Println(s0, cap(s0)) // [2 3 5] 3
    s1 := append(s0, 7)      // 添加一个元素
    fmt.Println(s1, cap(s1)) // [2 3 5 7] 6
    s2 := append(s1, 11, 13) // 添加两个元素
    fmt.Println(s2, cap(s2)) // [2 3 5 7 11 13] 6
    s3 := append(s0)         // <=> s3 := s0
    fmt.Println(s3, cap(s3)) // [2 3 5] 3
    s4 := append(s0, s0…)  // 以s0为基础添加s0中所有的元素
    fmt.Println(s4, cap(s4)) // [2 3 5 2 3 5] 6
    s0[0], s1[0] = 99, 789
    fmt.Println(s2[0], s3[0], s4[0]) // 789 99 2
}

    s4 := append(s0, s0[0], s0[1], s0[2])

    s1 := append(s0, []int{7}…)

    s2 := append(s1, []int{11, 13}…)

package main
import "fmt"
func main() {
    var s = append([]string(nil), "array", "slice")
    fmt.Println(s)      // [array]
    fmt.Println(cap(s)) // 2
    s = append(s, "map")
    fmt.Println(s)      // [array slice map]
    fmt.Println(cap(s)) // 4
    s = append(s, "channel")
    fmt.Println(s)      // [array slice map channel]
    fmt.Println(cap(s)) // 4
}

make(M, n)
make(M)

make(S, length, capacity)
make(S, length) // <=> make(S, length, length)

package main
import "fmt"
func main() {
    // 创建映射。
    fmt.Println(make(map[string]int)) // map[]
    m := make(map[string]int, 3)
    fmt.Println(m, len(m)) // map[] 0
    m["C"] = 1972
    m["Go"] = 2009
    fmt.Println(m, len(m)) // map[C:1972 Go:2009] 2
    // 创建切片。
    s := make([]int, 3, 5)
    fmt.Println(s, len(s), cap(s)) // [0 0 0] 3 5
    s = make([]int, 2)
    fmt.Println(s, len(s), cap(s)) // [0 0] 2 2
}

package main
import "fmt"
func main() {
    m := new(map[string]int)   // <=> var m map[string]int
    fmt.Println(m == nil)       // true
    s := new([]int)            // <=> var s []int
    fmt.Println(s == nil)       // true
    a := new([5]bool)          // <=> var a [5]bool
    fmt.Println(a == [5]bool{}) // true
}

package main
import "fmt"
func main() {
    a := [5]int{2, 3, 5, 7}
    s := make([]bool, 2)
    pa2, ps1 := &a[2], &s[1]
    fmt.Println(pa2, ps1) // 5 false
    a[2], s[1] = 99, true
    fmt.Println(pa2, ps1) // 99 true
    ps0 := &[]string{"Go", "C"}[0]
    fmt.Println(ps0) // Go
    m := map[int]bool{1: true}
     = m
    // 下面这几行编译不通过。
    /*
     = &[3]int{2, 3, 5}[0]
     = &map[int]bool{1: true}[1]
     = &m[1]
    /
}

package main
import "fmt"
func main() {
    type T struct{age int}
    mt := map[string]T{}
    mt["John"] = T{age: 29} // 整体修改是允许的
    ma := map[int][5]int{}
    ma[1] = [5]int{1: 789} // 整体修改是允许的
    // 这两个赋值编译不通过，因为部分修改一个映射
    // 元素是非法的。这看上去确实有些反直觉。
    /
    ma[1][1] = 123      // error
    mt["John"].age = 30 // error
    /
    // 读取映射元素的元素或者字段是没问题的。
    fmt.Println(ma[1][1])       // 789
    fmt.Println(mt["John"].age) // 29
}

为了让上例中的两行编译不通过的两行赋值语句编译通过，欲修改的映射元素必须先存放在一个临时变量中，然后修改这个临时变量，最后再用这个临时变量整体覆盖欲修改的映射元素。比如：

package main
import "fmt"
func main() {
    type T struct{age int}
    mt := map[string]T{}
    mt["John"] = T{age: 29}
    ma := map[int][5]int{}
    ma[1] = [5]int{1: 789}
    t := mt["John"] // 临时变量
    t.age = 30
    mt["John"] = t // 整体修改
    a := ma[1] // 临时变量
    a[1] = 123
    ma[1] = a // 整体修改
    fmt.Println(ma[1][1], mt["John"].age) // 123 30
}

### 从数组或者切片派生切片（取子切片） 我们可以从一个基础切片或者一个可寻址的基础数组派生出另一个切片。此派生操作也常称为一个取子切片操作。派生出来的切片的元素和基础切片（或者数组）的元素位于同一个内存片段上。或者说，派生出来的切片和基础切片（或者数组）将共享一些元素。 Go中有两种取子切片的语法形式（假设baseContainer是一个切片或者数组）：

baseContainer[low : high]       // 双下标形式
baseContainer[low : high : max] // 三下标形式

上面所示的双下标形式等价于下面的三下标形式：

baseContainer[low : high : cap(baseContainer)]

所以双下标形式是三下标形式的特例。在实践中，双下标形式使用得相对更为广泛。 （注意：三下标形式是从Go 1.2开始支持的。） 上面所示的取子切片表达式的语法形式中得下标必须满足下列关系，否则代码要么编译不通过，要么在运行时刻将造成恐慌。

// 双下标形式
0 <= low <= high <= cap(baseContainer)
// 三下标形式
0 <= low <= high <= max <= cap(baseContainer)

不满足上述关系的取子切片表达式要么编译不通过，要么在运行时刻将导致一个恐慌。 注意： - 只要上述关系均满足，下标low和high都可以大于len(baseContainer)。但是它们一定不能大于cap(baseContainer)。 - 如果baseContainer是一个零值nil切片，只要上面所示的子切片表达式中下标的值均为0，则此这两个子切片表达式不会造成恐慌。在这种情况下，结果切片也是一个nil切片。 子切片表达式的结果切片的长度为high - low、容量为max - low。派生出来的结果切片的长度可能大于基础切片的长度，但结果切片的容量绝不可能大于基础切片的容量。 在实践中，我们常常在子切片表达式中省略若干下标，以使代码看上去更加简洁。省略规则如下： - 如果下标low为零，则它可被省略。此条规则同时适用于双下标形式和三下标形式。 - 如果下标high等于len(baseContainer)，则它可被省略。此条规则同时只适用于双下标形式。 - 三下标形式中的下标max在任何情况下都不可被省略。比如，下面的子切片表达式都是相互等价的：

baseContainer[0 : len(baseContainer)]
baseContainer[: len(baseContainer)]
baseContainer[0 :]
baseContainer[:]
baseContainer[0 : len(baseContainer) : cap(baseContainer)]
baseContainer[: len(baseContainer) : cap(baseContainer)]

一个使用了子切片语法的例子：

package main
import "fmt"
func main() {
    a := […]int{0, 1, 2, 3, 4, 5, 6}
    s0 := a[:]     // <=> s0 := a[0:7:7]
    s1 := s0[:]    // <=> s1 := s0
    s2 := s1[1:3]  // <=> s2 := a[1:3]
    s3 := s1[3:]   // <=> s3 := s1[3:7]
    s4 := s0[3:5]  // <=> s4 := s0[3:5:7]
    s5 := s4[:2:2] // <=> s5 := s0[3:5:5]
    s6 := append(s4, 77)
    s7 := append(s5, 88)
    s8 := append(s7, 66)
    s3[1] = 99
    fmt.Println(len(s2), cap(s2), s2) // 2 6 [1 2]
    fmt.Println(len(s3), cap(s3), s3) // 4 4 [3 99 77 6]
    fmt.Println(len(s4), cap(s4), s4) // 2 4 [3 99]
    fmt.Println(len(s5), cap(s5), s5) // 2 2 [3 99]
    fmt.Println(len(s6), cap(s6), s6) // 3 4 [3 99 77]
    fmt.Println(len(s7), cap(s7), s7) // 3 4 [3 4 88]
    fmt.Println(len(s8), cap(s8), s8) // 4 4 [3 4 88 66]
}

下面这张图描绘了上面的程序在退出之前各个数组和切片的状态。 从这张图片可以看出，切片s7和s8共享存储它们的元素的底层内存片段，其它切片和数组a共享同一个存储元素的内存片段。 请注意，子切片操作有可能会造成暂时性的内存泄露。比如，下面在这个函数中开辟的内存块中的前50个元素槽位在它的调用返回之后将不再可见。这50个元素槽位所占内存浪费了，这属于暂时性的内存泄露。当这个函数中开辟的内存块今后不再被任何切片所引用，此内存块将被回收，这时内存才不再继续泄漏。

func f() []int {
    s := make([]int, 10, 100)
    return s[50:60]
}

请注意，在上面这个函数中，子切片表达式中的起始下标（50）比s的长度（10）要大，这是允许的。 ### 使用内置copy函数来复制切片元素 我们可以使用内置copy函数来将一个切片中的元素复制到另一个切片。这两个切片的类型可以不同，但是它们的元素类型必须相同。换句话说，这两个切片的类型的底层类型必须相同。copy函数的第一个参数为目标切片，第二个参数为源切片。传递给一个copy函数调用的两个实参可以共享一些底层元素。copy函数返回复制了多少个元素，此值（int类型）为这两个切片的长度的较小值。 结合上一节介绍的子切片语法，我们可以使用copy函数来在两个数组之间或者一个数组与一个切片之间复制元素。 一个例子：

package main
import "fmt"
func main() {
    type Ta []int
    type Tb []int
    dest := Ta{1, 2, 3}
    src := Tb{5, 6, 7, 8, 9}
    n := copy(dest, src)
    fmt.Println(n, dest) // 3 [5 6 7]
    n = copy(dest[1:], dest)
    fmt.Println(n, dest) // 2 [5 5 6]
    a := [4]int{} // 一个数组
    n = copy(a[:], src)
    fmt.Println(n, a) // 4 [5 6 7 8]
    n = copy(a[:], a[2:])
    fmt.Println(n, a) // 2 [7 8 7 8]
}

事实上，copy并不是一个基本函数。我们可以用append来实现它。

// 假设元素类型为T。
func Copy(dest, src []T) int {
    if len(dest) < len(src) {
         = append(dest[:0], src[:len(dest)]…)
        return len(dest)
    } else {
         = append(dest[:0], src…)
        return len(src)
    }
}

尽管copy函数不是一个基本函数，它比上面的用append的实现使用起来要方便得多。 从另外一个角度，我们也可以认为append不是一个基本函数，因为我们可以用make加copy函数来实现它。 注意，做为一个特例，copy函数可以用来将一个字符串中的字节复制到一个字节切片。 截至目前（Go 1.13），copy函数调用的两个实参均不能为类型不确定的nil。 ### 遍历容器元素 在Go中，我们可以使用下面的语法形式来遍历一个容器中的键值和元素：

for key, element = range aContainer {
    // 使用key和element …
}

在此语法形式中，for和range为两个关键字，key和element称为循环变量。如果aContainer是一个切片或者数组（或者数组指针，见后），则key的类型必须为内置类型int。 上面所示的for-range语法形式中的等号=也可以是一个变量短声明符号:=。当短声明符号被使用的时候，key和element总是两个新声明的变量，这时如果aContainer是一个切片或者数组（或者数组指针），则key的类型被推断为内置类型int。 和传统的for循环流程控制一样，每个for-range循环流程控制形成了两个代码块，其中一个是隐式的，另一个是显式的（花括号之间的部分）。此显式的代码块内嵌在隐式的代码块之中。 和for循环流程控制一样，break和continue也可以使用在一个for-range循环流程控制中的显式代码块中。 一个例子：

package main
import "fmt"
func main() {
    m := map[string]int{"C": 1972, "C++": 1983, "Go": 2009}
    for lang, year := range m {
        fmt.Printf("%v: %v \n", lang, year)
    }
    a := […]int{2, 3, 5, 7, 11}
    for i, prime := range a {
        fmt.Printf("%v: %v \n", i, prime)
    }
    s := []string{"go", "defer", "goto", "var"}
    for i, keyword := range s {
        fmt.Printf("%v: %v \n", i, keyword)
    }
}

for-range循环代码块有一些变种形式：

// 忽略键值循环变量。
for , element = range aContainer {
    // …
}
// 忽略元素循环变量。
for key,  = range aContainer {
    element = aContainer[key]
    // …
}
// 舍弃元素循环变量。此形式和上一个变种等价。
for key = range aContainer {
    element = aContainer[key]
    // …
}
// 键值和元素循环变量均被忽略。
for ,  = range aContainer {
    // 这个变种形势没有太大实用价值。
}
// 键值和元素循环变量均被舍弃。此形式和上一个变种等价。
for range aContainer {
    // 这个变种形势没有太大实用价值。
}

遍历一个nil映射或者nil切片是允许的。这样的遍历可以看作是一个空操作。 一些关于遍历映射条目的细节： - 映射中的条目的遍历顺序是不确定的（可以认为是随机的）。或者说，同一个映射中的条目的两次遍历中，条目的顺序很可能是不一致的，即使在这两次遍历之间，此映射并未发生任何改变。 - 如果在一个映射中的条目的遍历过程中，一个还没有被遍历到的条目被删除了，则此条目保证不会被遍历出来。 - 如果在一个映射中的条目的遍历过程中，一个新的条目被添加入此映射，则此条目并不保证将在此遍历过程中被遍历出来。如果可以确保没有其它协程操纵一个映射m，则下面的代码保证将清空m中所有条目。

for key := range m {
    delete(m, key)
}

当然，数组和切片元素也可以用传统的for循环来遍历。

for i := 0; i < len(anArrayOrSlice); i++ {
    element := anArrayOrSlice[i]
    // …
}

对一个for-range循环代码块

for key, element = range aContainer {…}

有三个重要的事实存在： - 被遍历的容器值是aContainer的一个副本。注意，只有aContainer的直接部分被复制了。此副本是一个匿名的值，所以它是不可被修改的。 - 如果aContainer是一个数组，那么在遍历过程中对此数组元素的修改不会体现到循环变量中。原因是此数组的副本（被真正遍历的容器）和此数组不共享任何元素。 - 如果aContainer是一个切片（或者映射），那么在遍历过程中对此切片（或者映射）元素的修改将体现到循环变量中。原因是此切片（或者映射）的副本和此切片（或者映射）共享元素（或条目）。 - 在遍历中的每个循环步，aContainer副本中的一个键值元素对将被赋值（复制）给循环变量。所以对循环变量的直接部分的修改将不会体现在aContainer中的对应元素中。（因为这个原因，并且for-range循环是遍历映射条目的唯一途径，所以最好不要使用大尺寸的映射键值和元素类型，以避免较大的复制负担。） - 所有被遍历的键值对将被赋值给同一对循环变量实例。下面这个例子验证了上述第一个和第二个事实。

package main
import "fmt"
func main() {
    type Person struct {
        name string
        age  int
    }
    persons := [2]Person {{"Alice", 28}, {"Bob", 25}}
    for i, p := range persons {
        fmt.Println(i, p)
        // 此修改将不会体现在这个遍历过程中，
        // 因为被遍历的数组是persons的一个副本。
        persons[1].name = "Jack"
        // 此修改不会反映到persons数组中，因为p
        // 是persons数组的副本中的一个元素的副本。
        p.age = 31
    }
    fmt.Println("persons:", &persons)
}

输出结果：

0 {Alice 28}
1 {Bob 25}
persons: &[{Alice 28} {Jack 25}]

如果我们将上例中的数组改为一个切片，则在循环中对此切片的修改将在循环过程中体现出来。但是对循环变量的修改仍然不会体现在此切片中。

…
    // 改为一个切片。
    persons := []Person {{"Alice", 28}, {"Bob", 25}}
    for i, p := range persons {
        fmt.Println(i, p)
        // 这次，此修改将反映在此次遍历过程中。
        persons[1].name = "Jack"
        // 这个修改仍然不会体现在persons切片容器中。
        p.age = 31
    }
    fmt.Println("persons:", &persons)
}

输出结果变成了：

0 {Alice 28}
1 {Jack 25}
persons: &[{Alice 28} {Jack 25}]

下面这个例子验证了上述的第二个和第三个事实：

package main
import "fmt"
func main() {
    langs := map[struct{ dynamic, strong bool }]map[string]int{
        {true, false}:  {"JavaScript": 1995},
        {false, true}:  {"Go": 2009},
        {false, false}: {"C": 1972},
    }
    // 此映射的键值和元素类型均为指针类型。
    // 这有些不寻常，只是为了讲解目的。
    m0 := map[struct{ dynamic, strong bool }]map[string]int{}
    for category, langInfo := range langs {
        m0[&category] = &langInfo
        // 下面这行修改对映射langs没有任何影响。
        category.dynamic, category.strong = true, true
    }
    for category, langInfo := range langs {
        fmt.Println(category, langInfo)
    }
    m1 := map[struct{ dynamic, strong bool }]map[string]int{}
    for category, langInfo := range m0 {
        m1[category] = langInfo
    }
    // 映射m0和m1中均只有一个条目。
    fmt.Println(len(m0), len(m1)) // 1 1
    fmt.Println(m1) // map[{true true}:map[C:1972]]
}

{false true} map[Go:2009]
{false false} map[C:1972]
{true false} map[JavaScript:1995]
1 1
map[{true true}:map[Go:2009]]

type Buffer struct {
    start, end int
    data       [1024]byte
}
func fa(buffers []Buffer) int {
    numUnreads := 0
    for _, buf := range buffers {
        numUnreads += buf.end - buf.start
    }
    return numUnreads
}
func fb(buffers []Buffer) int {
    numUnreads := 0
    for i := range buffers {
        numUnreads += buffers[i].end - buffers[i].start
    }
    return numUnreads
}

package main
import "fmt"
func main() {
    var a [100]int
    for i, n := range &a { // 复制一个指针的开销很小
        fmt.Println(i, n)
    }
    for i, n := range a[:] { // 复制一个切片的开销很小
        fmt.Println(i, n)
    }
}

package main
import "fmt"
func main() {
    var p [5]int // nil
    for i,  := range p { // okay
        fmt.Println(i)
    }
    for i := range p { // okay
        fmt.Println(i)
    }
    for i, n := range p { // panic
        fmt.Println(i, n)
    }
}

package main
import "fmt"
func main() {
    a := [5]int{2, 3, 5, 7, 11}
    p := &a
    p[0], p[1] = 17, 19
    fmt.Println(a) // [17 19 5 7 11]
    p = nil
     = p[0] // panic
}

package main
import "fmt"
func main() {
    pa := &[5]int{2, 3, 5, 7, 11}
    s := pa[1:3]
    fmt.Println(s) // [3 5]
    pa = nil
    s = pa[0:0] // panic
}

var pa [5]int // == nil
fmt.Println(len(pa), cap(pa)) // 5 5

for i := range a {
    a[i] = t0
}

s := a[:]
for i := range s {
    s[i] = t0
}

package main
import "fmt"
var a [5]int
var p [7]string
// N和M都是类型为int的类型确定值。
const N = len(a)
const M = cap(p)
func main() {
    fmt.Println(N) // 5
    fmt.Println(M) // 7
}

package main
import (
    "fmt"
    "reflect"
)
func main() {
    s := make([]int, 2, 6)
    fmt.Println(len(s), cap(s)) // 2 6
    reflect.ValueOf(&s).Elem().SetLen(3)
    fmt.Println(len(s), cap(s)) // 3 6
    reflect.ValueOf(&s).Elem().SetCap(5)
    fmt.Println(len(s), cap(s)) // 3 5
}

sClone := append(s[:0:0], s…)

sClone := make([]T, len(s))
copy(sClone, s)

// 第一种方法（保持剩余元素的次序）：
s = append(s[:from], s[to:]…)
// 第二种方法（保持剩余元素的次序）：
s = s[:from + copy(s[from:], s[to:])]
// 第三种方法（不保持剩余元素的次序）：
if n := to-from; len(s)-to < n {
    copy(s[from:to], s[to:])
} else {
    copy(s[from:to], s[len(s)-n:])
}
s = s[:len(s)-(to-from)]

// "len(s)+to-from"是删除操作之前切片s的长度。
temp := s[len(s):len(s)+to-from]
for i := range temp {
    temp[i] = t0
}

// 第一种方法（保持剩余元素的次序）：
s = append(s[:i], s[i+1:]…)
// 第二种方法（保持剩余元素的次序）：
s = s[:i + copy(s[i:], s[i+1:])]
// 上面两种方法都需要复制len(s)-i-1个元素。
// 第三种方法（不保持剩余元素的次序）：
s[i] = s[len(s)-1]
s = s[:len(s)-1]

s[len(s):len(s)+1][0] = t0
// 或者
s[:len(s)+1][len(s)] = t0

// 假设T是一个小尺寸类型。
func DeleteElements(s []T, keep func(T) bool, clear bool) []T {
    // result := make([]T, 0, len(s))
    result := s[:0] // 无须开辟内存
    for _, v := range s {
        if keep(v) {
            result = append(result, v)
        }
    }
    if clear { // 避免暂时性的内存泄露。
        temp := s[len(result):]
        for i := range temp {
            temp[i] = t0 // t0是类型T的零值
        }
    }
    return result
}

// 第一种方法:一行实现。
s = append(s[:i], append(elements, s[i:]…)…)
// 另一种效率更高的但较为繁琐的实现。
if cap(s)-len(s) >= len(elements) {
    s = s[:len(s)+len(elements)]
    copy(s[i+len(elements):], s[i:])
    copy(s[i:], elements)
} else {
    x := make([]T, 0, len(elements)+len(s))
    x = append(x, s[:i]…)
    x = append(x, elements…)
    x = append(x, s[i:]…)
    s = x
}
// Push（插入到结尾）。
s = append(s, elements…)
// Unshift（插入到开头）。
s = append(elements, s…)

// 前弹出（pop front，又称shift）
s, e = s[1:], s[0]
// 后弹出（pop back）
s, e = s[:len(s)-1], s[len(s)-1]
// 前推（push front）
s = append([]T{e}, s…)
// 后推（push back）
s = append(s, e)