Golang 笔记（三）：一种理解 Slice 的模型

// 数组的几种初始化方式
var a [4]int             // 变量 a 类型为 [4]int 是一个 type，每个元素自动初始化为 int 的零值（zero-value）
b := [5]int{1,2,3,4}     // 变量 b 类型为 [5]int 是不同于 [4]int 的类型，且 b[4] 会自动初始化为 int 的零值
c := [...]int{1,2,3,4,5} // 变量 c 被自动推导为 [5]int 类型，与 b 类型同
func echo(x [4]int) {
  fmt.Println(x)
}
echo(a)         // echo 调用时，a 中所有元素都会被复制一遍， 因为 Go 函数调用是传值
echo(b)         // error
echo(([4]int)c) // error

type slice struct {
    array unsafe.Pointer // 指向底层数组的指针；对，golang 也是有指针的
    len   int            // 切片长度
    cap   int            // 底层数组长度
}
// 切片的几种初始化方式
s0 := make([]byte, 5)       // 借助 make 函数，此时 len = cap = 5，每个元素初始化为 byte 的 zero-value
s1 := []byte{0, 0, 0, 0, 0} // 字面值初始化，此时 len = cap = 5
var s2 []byte               // 自动初始化为 slice 的“零值(zero-value)”：nil
// make 方式同时指定 len/cap，需满足 len <= cap
s3 := make([]byte, 0, 5) // 切片长度 len = 0, 底层数组 cap = 5
s4 := make([]byte, 5, 5) // 等价于 make([]byte, 5)

// 截取操作，左闭右开；若始于起点，或止于终点，则可省略对应下标
// 新得到的切片与原始切片共用底层数组，因此免于元素复制
b := []byte{'g', 'o', 'l', 'a', 'n', 'g'}
b1 := b[1:4] // b1 == []byte{'o', 'l', 'a'}
b2 := b[:2]  // b2 == []byte{'g', 'o'}
b3 := b[2:]  // b3 == []byte{'l', 'a', 'n', 'g'}
b4 := b[:]   // b4 == b
// 扩展操作，需借助 append 函数
// 可能会引起底层数组的重新分配，后面会详细分析
// 等价于 b = append(b, []byte{',', 'h', 'i'}...)
b = append(b, ',', 'h', 'i') // b 现为 {'g', 'o', 'l', 'a', 'n', 'g', ',', 'h', 'i'}
// 赋值操作，需借助 copy 函数
copy(b[:2], []byte{'e', 'r'})  // b 现为 {'e', 'r', 'l', 'a', 'n', 'g', ',', 'h', 'i'}
// 移动操作，需借助 copy
copy(b[2:], b[6:])  // 移动长度取 min(len(dst), len(src))
b = b[:5]           // b 现为 {'e', 'r', ',', 'h', 'i'}

b := []int{1,2,3,4}
c := []int{1,2,3,4,5} 
func echo(x []int) {
  fmt.Println(x)
}
echo(b) // 传递参数时，会重新生成一个共享底层数组，len 和 cap 都相同的切片结构体
echo(c)

package main
import (
 "fmt"
)
// 直觉认为的 copy 函数实现
// 但此种实现会造成同一个切片的子切片进行复制时的覆盖现象
// 因此 copy 在实现时应该借助了额外的空间 or 从后往前复制
func myCopy(dst, src []int) {
 l := len(dst)
 if len(src) < l {
  l = len(src)
 }
 for i := 0; i < l; i++ {
  dst[i] = src[i]
 }
}
func main() {
 a := []int{0,1,3,4,5,6}
 copy(a[3:], a[2:])      // a = [0 1 3 3 4 5]
 // myCopy(a[3:], a[2:]) // a = [0 1 3 3 3 3]
 fmt.Println(a)
}

func add(a []int) []int { // nil 可以作为参数传给 []int 切片类型
 return append(a, 0, 1, 2)
}
func main() {
 fmt.Println(add(nil)) // [0 1 2]
}

func main() {
 a := make([]int, 0)
 var b []int
 fmt.Println(a, len(a), cap(a)) // [] 0 0
 fmt.Printf("%#v\n", a)         // []int{}
 fmt.Println(a==nil)            // false
 fmt.Println(b, len(b), cap(b)) // [] 0 0
  fmt.Printf("%#v\n", b)         // []int(nil)
 fmt.Println(b==nil)            // true
}

func main() {
 a := make([]int, 0, 5)
 _ = append(a, 0, 1, 2)
 fmt.Println(a)     // []
 fmt.Println(a[:5]) // [0 1 2 0 0]；通过切片表达式，扩大窗口长度，就可以看到追加的值
  fmt.Println(a[:6]) // panic；长度越界了
}

func main() {
 a := [7]int{1,2,3}
 s := a[:4]
 fmt.Println(s) // [1 2 3 0]
 a[3] = 4       // 修改 a，s 相应值也跟着变化，说明 s 的底层就是 a
 fmt.Println(s) // [1 2 3 4]
}