速战速决 go - go 容器: 切片，通过范围获取切片，切片的构造，切片数据的添加/复制/删除，数组和切片的区别

速战速决 go https://github.com/webabcd/GoSample

作者 webabcd

示例如下:

container/slice.go

// go 容器 - 切片（通过范围获取切片，切片的构造，切片数据的添加/复制/删除，数组和切片的区别）

// 数组是内存中的一段连续空间，切片是对数组的某一段连续空间的引用
// 数组是固定长度的，切片是长度可变的
// 数组是指针指向的值，切片是一个指针（也就是所谓的数组是值类型，切片是引用类型）

package container

import (
        "fmt"
        "reflect"
)

func SliceSample() {
        slice_sample1()
        slice_sample2()
        slice_sample3()
        slice_sample4()
        slice_sample5()
        slice_sample6()
}

// 从数组或切片中获取指定范围的切片
func slice_sample1() {
        var a = [5]int{1, 2, 3, 4, 5}

        // 获取指定位置范围的切片（左闭右开原则，即包括左边，不包括右边）
        fmt.Println(a[0:3]) // [1 2 3]
        fmt.Println(a[:5])  // [1 2 3 4 5]
        fmt.Println(a[0:])  // [1 2 3 4 5]
        fmt.Println(a[0:0]) // []
        fmt.Println(a[:])   // [1 2 3 4 5]

        // a 是数组，它是固定长度的
        fmt.Println(reflect.TypeOf(a)) // [5]int
        // a[:] 是切片，它的长度是可变的
        fmt.Println(reflect.TypeOf(a[:])) // []int

        // 注：切片之间是不能通过 == 做相等判断的，下面这句会编译时报错
        // fmt.Println(a[:] == a[:])
}

// 构造切片
func slice_sample2() {
        // 构造一个切片
        //   第 2 个参数表示切片初始化时元素的个数
        //   第 3 个参数表示初始化时，为切片分配的初始空间的长度
        //     如果不指定此参数，则其值同第 2 个参数
        //     后续，如果切片中的元素个数发生了变化，系统会根据它自己的逻辑决定是否重新分配空间
        var a []int = make([]int, 2)
        b := make([]int, 2, 10)

        // 构造一个切片，并初始化（与数组的区别是 [] 里面啥都没有）
        c := []int{0, 0}

        // len() - 获取切片的长度
        // cap() - 获取切片的占用空间的长度
        fmt.Println(a, b, c, len(a), len(b), len(c), cap(a), cap(b), cap(c)) // [0 0] [0 0] [0 0] 2 2 2 2 10 2
}

// 在切片的头部或尾部添加数据
func slice_sample3() {
        a := []int{}

        // 在尾部添加元素
        a = append(a, 0, 1, 2)
        a = append(a, []int{3, 4, 5}...)
        fmt.Println(a) // [0 1 2 3 4 5]

        // 在开头添加元素
        a = append([]int{-3, -2, -1}, a...)
        fmt.Println(a) // [-3 -2 -1 0 1 2 3 4 5]
}

// 切片的复制
func slice_sample4() {
        a := []int{1, 2, 3, 4, 5}
        b := make([]int, 10)
        c := make([]int, 10)

        // 将 a 复制给 b（返回值为复制的元素个数）
        d := copy(b, a)

        // 将 a[2:5] 复制给 c[2:5]（返回值为复制的元素个数）
        e := copy(c[2:5], a[2:5])

        fmt.Println(a, b, c, d, e) // [1 2 3 4 5] [1 2 3 4 5 0 0 0 0 0] [0 0 3 4 5 0 0 0 0 0] 5 3
}

// 切片中元素的删除
func slice_sample5() {
        a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}
        fmt.Println(a) // [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18]

        a = a[2:]        // 删除开头 2 个元素
        a = a[:len(a)-2] // 删除尾部 2 个元素
        fmt.Println(a)   // [3 4 5 6 7 8 9 10 11 12 13 14 15 16]

        a = append(a[:0], a[2:]...) // 删除开头 2 个元素
        a = a[:copy(a, a[2:])]      // 删除开头 2 个元素
        fmt.Println(a)              // [7 8 9 10 11 12 13 14 15 16]

        a = append(a[:2], a[5:]...)  // 删除索引位置 2 到 4 之间的 3 个元素
        a = a[:2+copy(a[2:], a[5:])] // 删除索引位置 2 到 4 之间的 3 个元素
        fmt.Println(a)               // [7 8 15 16]
}

// 数组和切片的区别
func slice_sample6() {
        // 数组，固定长度
        a := [3]int{1, 2, 3}
        // 切片，长度可变
        b := []int{1, 2, 3}

        // 数组 a 是指针指向的值
        // 切片 b 是一个指针
        fmt.Printf("%v, %v, %T, %T, %p, %p\n", a, b, a, b, &a, b) // [1 2 3], [1 2 3], [3]int, []int, 0xc00000e168, 0xc00000e180

        // 切片是对数组的一段连续区域的引用
        c := a[:2]
        d := a[1:]
        // 所以指针 &a 和指针 c 是一样的，而指针 &a 和指针 d 是不一样的
        fmt.Printf("%v, %v, %v, %p, %p, %p\n", a, c, d, &a, c, d) // [1 2 3], [1 2], [2 3], 0xc00000e168, 0xc00000e168, 0xc00000e170
}

速战速决 go https://github.com/webabcd/GoSample

作者 webabcd