Go程序例子(9)：切片

package main

import (
    "fmt"
    "slices"
)

func main() {
	// 与数组不同，切片仅由它们包含的元素类型决定（而不是元素的数量）。未初始化的切片等于 nil，长度为 0。
    var s []string
    fmt.Println("uninit:", s, s == nil, len(s) == 0)
	// 要创建一个非零长度的空切片，使用内置的 make 函数。这里我们创建了一个长度为 3 的字符串切片（初始时为零值）。默认情况下，新切片的容量等于其长度；如果提前知道切片将会增长，可以显式地传递一个额外的容量参数给 make。
    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])
	// len 返回切片的长度，这是符合预期的。
    fmt.Println("len:", len(s))
	// 切片的 append 函数是一个非常强大的内置操作，它允许我们向切片中添加一个或多个新元素。重要的是要注意，append 返回一个新的切片，所以我们必须接收这个返回值。
    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)
	// 切片还支持复制操作。我们可以创建一个与原切片相同长度的目标切片，并使用 copy 函数将源切片的元素复制到目标切片中。
    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)
	// 切片支持使用 `slice[low:high]` 语法的切片操作。例如，这种语法可以获取从索引 2 到 4（不包含 4）的元素，即 s[2]、s[3] 和 s[4]。
    l := s[2:5]
    fmt.Println("sl1:", l)
	// 这表示切片操作会包含到 s[4]，但不包括 s[5]。
    l = s[:5]
    fmt.Println("sl2:", l)
	// 这表示从 s[2] 开始（包含 s[2]）进行切片。
    l = s[2:]
    fmt.Println("sl3:", l)
	// 我们也可以在一行中声明并初始化一个切片变量。
    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)
	// slices 包中包含许多针对切片的实用工具函数。
    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)
    // 请注意，尽管切片与数组是不同的类型，但它们在使用 fmt.Println 输出时的表现是类似的。
}

$ 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]]