Go语言中切片作为函数参数的陷阱：理解值传递与底层数组

package main

import (
    "fmt"
)

type Pair struct {
    a int
    b int
}
type PairAndFreq struct {
    Pair
    Freq int
}

type PairSlice []PairAndFreq

type PairSliceSlice []PairSlice

func (pss PairSliceSlice) Weed() {
    fmt.Println("Before weed:", pss[0]) // 打印原始切片
    weed(pss[0])
    fmt.Println("After weed:", pss[0])  // 再次打印原始切片
}

func weed(ps PairSlice) { // ps 是 pss[0] 切片头部的副本
    m := make(map[Pair]int)

    for _, v := range ps {
        m[v.Pair]++ // 统计频率
    }

    // 关键操作1: ps = ps[:0]
    // 这将局部切片 ps 的长度设为 0，但容量不变，并且它仍然指向原始的底层数组。
    ps = ps[:0] 

    // 关键操作2: append
    // 这里的 append 操作会修改 ps 的内容。
    // 如果容量足够，它会直接修改 ps 当前指向的底层数组。
    // 如果容量不足，它会分配一个新的底层数组，并更新 ps 指向新数组。
    for k, v := range m {
        ps = append(ps, PairAndFreq{k, v})
    }
    fmt.Println("Inside weed (local ps):", ps) // 打印函数内部的 ps
}

func main() {
    pss := make(PairSliceSlice, 12)
    // 初始化 pss[0]，它是一个长度为2，容量为2的切片（假设）
    pss[0] = PairSlice{PairAndFreq{Pair{1, 1}, 1}, PairAndFreq{Pair{1, 1}, 1}}

    pss.Weed()
}

package main

import (
    "fmt"
)

type Pair struct {
    a int
    b int
}
type PairAndFreq struct {
    Pair
    Freq int
}

type PairSlice []PairAndFreq

type PairSliceSlice []PairSlice

func (pss PairSliceSlice) WeedAndAssign() {
    fmt.Println("Before weed:", pss[0])
    // 调用 weed 函数，并将返回的新切片赋值给 pss[0]
    pss[0] = weedWithReturn(pss[0]) 
    fmt.Println("After weed:", pss[0])
}

// weedWithReturn 函数现在返回一个 PairSlice
func weedWithReturn(ps PairSlice) PairSlice { 
    m := make(map[Pair]int)

    for _, v := range ps {
        m[v.Pair]++
    }

    // 创建一个新的切片来存储结果，而不是修改传入的副本
    resultPs := make(PairSlice, 0, len(m)) // 预分配容量以优化性能
    for k, v := range m {
        resultPs = append(resultPs, PairAndFreq{k, v})
    }
    fmt.Println("Inside weed (returned ps):", resultPs)
    return resultPs // 返回新的切片
}

func main() {
    pss := make(PairSliceSlice, 12)
    pss[0] = PairSlice{PairAndFreq{Pair{1, 1}, 1}, PairAndFreq{Pair{1, 1}, 1}}

    pss.WeedAndAssign()
}

Before weed: [{{1 1} 1} {{1 1} 1}]
Inside weed (returned ps): [{{1 1} 2}]
After weed: [{{1 1} 2}]

package main

import (
    "fmt"
)

type Pair struct {
    a int
    b int
}
type PairAndFreq struct {
    Pair
    Freq int
}

type PairSlice []PairAndFreq

type PairSliceSlice []PairSlice

func (pss PairSliceSlice) WeedWithPointer() {
    fmt.Println("Before weed:", pss[0])
    // 传递 pss[0] 的地址
    weedWithPointer(&pss[0]) 
    fmt.Println("After weed:", pss[0])
}

// weedWithPointer 接收一个 *PairSlice 类型的参数
func weedWithPointer(ps *PairSlice) { 
    m := make(map[Pair]int)

    // 访问切片内容时需要解引用 *ps
    for _, v := range *ps { 
        m[v.Pair]++
    }

    // 创建一个新的切片来存储结果
    newPs := make(PairSlice, 0, len(m))
    for k, v := range m {
        newPs = append(newPs, PairAndFreq{k, v})
    }
    fmt.Println("Inside weed (newPs):", newPs)

    // 将原始切片指针指向新创建的切片
    *ps = newPs 
}

func main() {
    pss := make(PairSliceSlice, 12)
    pss[0] = PairSlice{PairAndFreq{Pair{1, 1}, 1}, PairAndFreq{Pair{1, 1}, 1}}

    pss.WeedWithPointer()
}

Before weed: [{{1 1} 1} {{1 1} 1}]
Inside weed (newPs): [{{1 1} 2}]
After weed: [{{1 1} 2}]