1
var s []int64
2
fmt.Println(unsafe.Sizeof(s))  // 24（指针8 + len8 + cap8）

1
// 1. 字面量
2
s1 := []int{1, 2, 3}  // len=3, cap=3
3

4
// 2. make
5
s2 := make([]int, 5)      // len=5, cap=5，元素零值
6
s3 := make([]int, 3, 10)  // len=3, cap=10
7

8
// 3. 从数组切片
9
arr := [10]int{1, 2, 3, 4, 5}
10
s4 := arr[2:5]  // len=3, cap=8（共享底层数组！）

1
arr := [5]int{10, 20, 30, 40, 50}
2
s := arr[1:3]  // s = [20, 30]
3

4
// 底层等价于：
5
// s.Data = &arr[1]     // 指向 arr 的第 1 个元素
6
// s.Len  = 3 - 1 = 2   // 长度
7
// s.Cap  = 5 - 1 = 4   // 容量 = 数组长度 - 起始索引

1
// src/runtime/slice.go (简化版)
2
func growslice(old Slice, et *type, num int) Slice {
3
    oldCap := old.Cap
4
    newCap := oldCap + num
5

6
    // 扩容规则
7
    switch {
8
    case newCap < 2*oldCap:
9
        newCap = 2 * oldCap  // 翻倍
10
    case oldCap < 256:
11
        newCap = 2 * oldCap  // 小 slice：翻倍
12
    default:
13
        // 大 slice：1.25 倍增长（避免浪费太多内存）
14
        for newCap < oldCap + num {
15
            newCap += (newCap + 3*256) / 4
16
        }
17
    }
18

19
    // 内存对齐
20
    var lenmem, capmem uintptr
21
    capmem = roundupsize(uintptr(newCap) * goarch.PtrSize)
22
    newCap = int(capmem / goarch.PtrSize)
23

24
    // 分配新数组并复制
25
    p := mallocgc(capmem, et, true)
26
    memmove(p, old.Data, lenmem)
27

28
    return Slice{Data: p, Len: old.Len, Cap: newCap}
29
}

1
// 三索引切片：限制容量，防止共享
2
s1 := s[1:3:3]  // s1 = [2, 3], cap=2（不再是4）
3
// 现在 append(s1, x) 会分配新数组，不会影响 s2

1
s1 := "hello, world"
2
s2 := s1[7:]  // s2 = "world"
3

4
// s1 和 s2 共享底层数据！
5
// s2.Data = s1.Data + 7
6
// s2.Len = s1.Len - 7 = 5

1
s := "hello"
2
b := []byte(s)    // 分配新内存，拷贝数据
3
s2 := string(b)   // 分配新内存，拷贝数据

1
// 零拷贝：string → []byte（不分配内存）
2
func str2bytes(s string) []byte {
3
    return *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{
4
        Data: (*reflect.StringHeader)(unsafe.Pointer(&s)).Data,
5
        Len:  len(s),
6
        Cap:  len(s),
7
    }))
8
}
9

10
// 零拷贝：[]byte → string（不分配内存）
11
func bytes2str(b []byte) string {
12
    return *(*string)(unsafe.Pointer(&reflect.SliceHeader{
13
        Data: (*reflect.StringHeader)(unsafe.Pointer(&b)).Data,
14
        Len:  len(b),
15
        Cap:  len(b),
16
    }))
17
}

1
// 优化 1：map 查找中的 []byte 转 string
2
m := map[string]int{}
3
b := []byte("key")
4
_ = m[string(b)]  // 编译器优化：不分配内存
5

6
// 优化 2：字符串拼接
7
s := "hello" + " " + "world"  // 编译器在编译时完成拼接
8

9
// 优化 3：range string
10
for i, r := range "hello" {
11
    // 编译器优化：不转换为 []rune
12
    _ = i; _ = r
13
}

1
// 每次复制整个 slice
2
s := make([]int, 1000000)
3
s = append(s, 1)  // 复制 1000000 个 int！
4

5
// 预分配足够容量
6
s := make([]int, 0, 1000001)
7
s = append(s, 1)  // 不需要复制

1
// 每次转换都分配内存
2
func process(s string) []byte {
3
    return []byte(s)  // 分配 + 拷贝
4
}
5

6
// 使用 []byte 参数，避免转换
7
func processBytes(b []byte) []byte {
8
    return b  // 无拷贝
9
}

1
// s2 持有 s1 的整个底层数组引用，s1 无法被 GC
2
s1 := string(make([]byte, 1<<30))  // 1GB
3
s2 := s1[:10]  // 只需要 10 字节，但 1GB 无法释放
4

5
// 手动复制
6
s2 := string([]byte(s1[:10]))  // 只分配 10 字节

1
var s1 []int        // nil slice: Data=nil, Len=0, Cap=0
2
s2 := []int{}       // 空 slice: Data!=nil, Len=0, Cap=0
3
s3 := make([]int, 0) // 空 slice: Data!=nil, Len=0, Cap=0
4

5
// 功能上等价：len、cap、range 都一样
6
// 区别：JSON 编码时 nil → null，空 slice → []

1
var b strings.Builder
2
b.Grow(estimatedSize)  // 预分配
3
for _, s := range parts {
4
    b.WriteString(s)   // 不会每次分配
5
}
6
result := b.String()   // 一次分配