Go by Example: Slices

切片是Go中一种重要的数据类型，它提供了比数组更强大的序列接口。

与数组不同，切片仅由它们包含的元素（而不是元素数量）进行类型化。未初始化的切片等于nil，长度为0。

要创建一个非零长度的空切片，请使用内置的make。在这里，我们创建一个长度为3的字符串切片（最初为零值）。默认情况下，新切片的容量等于其长度；如果我们事先知道切片将提前增长，可以将容量作为附加参数显式传递给make。

我们可以像数组一样设置和获取。

len返回切片的长度，如预期的那样。

除了这些基本操作外，切片还支持一些使其比数组更丰富的操作。一个是内置的append，它返回一个包含一个或多个新值的切片。请注意，我们需要接受append的返回值，因为我们可能会获得新的切片值。

切片也可以复制。在这里，我们创建一个与s长度相同的空切片c，并将s的内容复制到c中。

切片支持带有语法slice[low:high]的“切片”操作符。

我们还可以在一行中声明并初始化切片变量。

slices包包含许多有用的实用函数，用于处理切片。

切片可以组合成多维数据结构。内部切片的长度可以变化，这与多维数组不同。

请注意，虽然切片与数组的类型不同，但它们在fmt.Println中的呈现方式相似。

package main

import (
    "fmt"
    "slices"
)

func main() {

    var s []string
    fmt.Println("uninit:", s, s == nil, len(s) == 0)

    s = make([]string, 3)
    fmt.Println("emp:", s, "len:", len(s), "cap:", cap(s))

    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])

    fmt.Println("len:", len(s))

    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)

    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

    l := s[2:5]
    fmt.Println("sl1:", l)

    l = s[:5]
    fmt.Println("sl2:", l)

    l = s[2:]
    fmt.Println("sl3:", l)

    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)

    t2 := []string{"g", "h", "i"}
    if slices.Equal(t, t2) {
        fmt.Println("t == t2")
    }

    twoD := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

$ go run slices.go
uninit: [] true true
emp: [  ] len: 3 cap: 3
set: [a b c]
get: c
len: 3
apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
t == t2
2d:  [[0] [1 2] [2 3 4]]