切片原理 #

type slice struct {
    ptr unsafe.Pointer  // 指向底层数组的指针
    len int             // 长度
    cap int             // 容量
}

切片变量
┌─────────────────────────────────┐
│ ptr ──────┐  len  │  cap       │
└───────────┼─────────────────────┘
            │
            ▼
底层数组
┌───┬───┬───┬───┬───┬───┬───┬───┐
│ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │
└───┴───┴───┴───┴───┴───┴───┴───┘
      ↑               ↑
      │               │
      └─ 切片范围 ─────┘
      len=4, cap=6

s := make([]int, 3, 6)
fmt.Printf("len=%d, cap=%d\n", len(s), cap(s))

s = append(s, 1, 2)
fmt.Printf("len=%d, cap=%d\n", len(s), cap(s))

s := []int{1, 2, 3}
// 底层：创建数组，切片指向它

s := make([]int, 3, 6)
// 底层：分配数组，创建切片

arr := [5]int{1, 2, 3, 4, 5}
s := arr[1:4]
// 底层：切片指向arr的子区间

s := []int{1, 2, 3, 4, 5}
s1 := s[1:3]      // len=2, cap=4
s2 := s[1:3:3]    // len=2, cap=2

s := make([]int, 0, 2)
s = append(s, 1, 2)  // len=2, cap=2
s = append(s, 3)     // 触发扩容

s := make([]int, 0)

for i := 0; i < 20; i++ {
    s = append(s, i)
    fmt.Printf("len=%d, cap=%d\n", len(s), cap(s))
}

// 输出:
// len=1, cap=1
// len=2, cap=2
// len=3, cap=4
// len=4, cap=4
// len=5, cap=8
// len=6, cap=8
// ...

func growslice(oldSlice, newLen) {
    newCap := calculateNewCap(oldSlice.cap, newLen)
    newArray := malloc(newCap * elementSize)
    copy(newArray, oldSlice.ptr, oldSlice.len)
    return slice{ptr: newArray, len: newLen, cap: newCap}
}

s1 := []int{1, 2, 3, 4, 5}
s2 := s1[1:3]  // 共享底层数组

s2[0] = 20
fmt.Println(s1)  // [1 20 3 4 5]

s1 := []int{1, 2, 3, 4, 5}
s2 := s1[1:3]  // len=2, cap=4

// s2可以访问s1[3]和s1[4]（通过扩容）
s2 = append(s2, 30, 40)
fmt.Println(s1)  // [1 2 3 30 40]（修改了s1）

s1 := []int{1, 2, 3, 4, 5}
s2 := s1[1:3:3]  // len=2, cap=2

s2 = append(s2, 30)  // 扩容，新数组
fmt.Println(s1)      // [1 2 3 4 5]（未改变）

// 不好：频繁扩容
var s []int
for i := 0; i < 10000; i++ {
    s = append(s, i)
}

// 好：预分配
s := make([]int, 0, 10000)
for i := 0; i < 10000; i++ {
    s = append(s, i)
}

// 不好：复制整个切片
func process(s []int) []int {
    result := make([]int, len(s))
    copy(result, s)
    // 处理result...
    return result
}

// 好：直接使用
func process(s []int) {
    // 直接处理s
}

var buf [1024]byte
n, _ := conn.Read(buf[:])
process(buf[:n])

var pool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 1024)
    },
}

func process() {
    buf := pool.Get().([]byte)
    defer pool.Put(buf)
    
    // 使用buf...
}

func leak() []int {
    arr := [10000]int{1, 2, 3, ...}
    return arr[:10]  // 返回的切片引用整个数组
}

func noLeak() []int {
    arr := [10000]int{1, 2, 3, ...}
    result := make([]int, 10)
    copy(result, arr[:10])
    return result  // 只复制需要的部分
}

type Data struct {
    Value int
    Info  []byte
}

func remove(s []*Data, i int) []*Data {
    s[i] = nil  // 置nil，允许GC回收
    return append(s[:i], s[i+1:]...)
}

arr := [5]int{1, 2, 3, 4, 5}
s := arr[:]  // 切片引用数组

s := []int{1, 2, 3, 4, 5}
arr := [5]int(s)  // Go 1.20+

s := []int{1, 2, 3, 4, 5}
arr := (*[5]int)(s)  // 共享底层数据

s1 := []int{1, 2, 3}
s2 := s1

s1 = append(s1, 4)  // 可能不扩容
fmt.Println(s2)     // [1 2 3] 或 [1 2 3 4]

s1 = append(s1, 5, 6, 7)  // 扩容
fmt.Println(s2)           // [1 2 3]（未改变）

func appendValue(s []int) {
    s = append(s, 1)  // 可能改变s的指针
}

func main() {
    s := []int{1, 2, 3}
    appendValue(s)
    fmt.Println(s)  // 可能是 [1 2 3] 或 [1 2 3 1]
}

var s1 []int        // nil切片
s2 := []int{}       // 空切片
s3 := make([]int, 0) // 空切片

fmt.Println(s1 == nil)  // true
fmt.Println(s2 == nil)  // false
fmt.Println(s3 == nil)  // false

s := make([]int, 0, expectedSize)

s := data[low:high:max]  // 限制容量

// 复制需要的数据
result := make([]int, len(s))
copy(result, s)

// 返回新切片
func process(s []int) []int {
    result := make([]int, len(s))
    // ...
    return result
}