更大的slice

append 函数

• append 函数也是内置函数，它可以将元素添加到 slice 里面。

package main
import "fmt"
func main() {
    dwarfs := []string{"Ceres", "Pluto", "Haumea", "Makemake", "Eris"}
    dwarfs = append(dwarfs, "Orcus")
    fmt.Println(dwarfs)
    dwarfs = append(dwarfs, "Salacia", "Quaoar", "Sedna")
    fmt.Println(dwarfs)
}

长度和容量（length & capacity）

• Slice 中元素的个数决定了 slice 的长度。
• 如果 slice 的底层数组比 slice 还大，那么就说该 slice 还有容量可供增长。

package main
import "fmt"
// dump slice length, capacity, and contents
func dump(label string, slice []string) {
    fmt.Printf("%v: length %v, capacity %v %v\n", label, len(slice), cap(slice), slice)
}
func main() {
    dwarfs := []string{"Ceres", "Pluto", "Haumea", "Makemake", "Eris"}
    dump("dwarfs", dwarfs)
    dump("dwarfs[1:2]", dwarfs[1:2])
}

详解 append

package main
import "fmt"
func dump(label string, slice []string) {
    fmt.Printf("%v: length %v, capacity %v %v\n", label, len(slice), cap(slice), slice)
}
func main() {
    dwarfs1 := []string{"Ceres", "Pluto", "Haumea", "Makemake", "Eris"}
    dwarfs2 := append(dwarfs1, "Orcus")
    dwarfs3 := append(dwarfs2, "Salacia", "Quaoar", "Sedna")
    dump("dwarfs1", dwarfs1)
    dump("dwarfs2", dwarfs2)
    dump("dwarfs3", dwarfs3)
    dwarfs3[1] = "Pluto!"
    dump("dwarfs1", dwarfs1)
    dump("dwarfs2", dwarfs2)
    dump("dwarfs3", dwarfs3)
}

三个索引的切分操作

• Go 1.2 中引入了能够限制新建切片容量的三索引切分操作。

package main
import "fmt"
// dump slice length, capacity, and contents
func dump(label string, slice []string) {
    fmt.Printf("%v: length %v, capacity %v %v\n", label, len(slice), cap(slice), slice)
}
func main() {
    planets := []string{
        "Mercury", "Venus", "Earth", "Mars",
        "Jupiter", "Saturn", "Uranus", "Neptune",
    }
    terrestrial := planets[0:4:4]
    worlds := append(terrestrial, "Ceres")
    fmt.Println(planets)
    dump("terrestrial", terrestrial)
    terrestrial = planets[0:4]
    worlds = append(terrestrial, "Ceres")
    fmt.Println(planets)
    dump("terrestrial", terrestrial)
    _ = worlds
}

使用 make 函数对 slice 进行预分配

• 当 slice 的容量不足以执行 append 操作时，Go 必须创建新数组并复制旧数组中的内容。
• 但通过内置的 make 函数，可以对 slice 进行预分配策略。
  • 尽量避免额外的内存分配和数组复制操作。

package main
import "fmt"
func main() {
    dwarfs := make([]string, 0, 10)
    dwarfs = append(dwarfs, "Ceres", "Pluto", "Haumea", "Makemake", "Eris")
    fmt.Println(dwarfs)
}

声明可变参数的函数

• 声明 Printf、append 这样的可变参数函数，需要在函数的最后一个参数前面加上 … 符号。

package main
import "fmt"
func terraform(prefix string, worlds ...string) []string {
    newWorlds := make([]string, len(worlds))
    for i := range worlds {
        newWorlds[i] = prefix + " " + worlds[i]
    }
    return newWorlds
}
func main() {
    twoWorlds := terraform("New", "Venus", "Mars")
    fmt.Println(twoWorlds)
    planets := []string{"Venus", "Mars", "Jupiter"}
    newPlanets := terraform("New", planets...)
    fmt.Println(newPlanets)
}

作业

• 编写一个程序：
  • 通过循环，持续的将元素追加到 slice 里
  • 在 slice 容量发生变化的时候打印出它的容量
  • 请判断 append 函数在底层数组的空间被填满之后，是否会将数组的容量增加一倍？

package main
import "fmt"
func main() {
    s := []string{}
    lastCap := cap(s)
    for i := 0; i < 10000; i++ {
        s = append(s, "An element")
        if cap(s) != lastCap {
            fmt.Println(cap(s))
            lastCap = cap(s)
        }
    }
}