将切片作为函数参数传递，并修改原始切片

Question

我知道在 Go 中一切都是按值传递的，这意味着如果我给一个函数一个切片，并且该函数使用内置的 append 函数附加到切片，那么原始切片将没有附加的值函数的范围。

例如：

nums := []int{1, 2, 3}

func addToNumbs(nums []int) []int {
    nums = append(nums, 4)
    fmt.Println(nums) // []int{1, 2, 3, 4}
}

fmt.Println(nums) // []int{1, 2, 3}

这给我带来了一个问题，因为我试图在一个累积切片上进行递归，基本上是一个 reduce 类型的函数，除了 reducer 调用自身。

这是一个例子：

func Validate(obj Validatable) ([]ValidationMessage, error) {
    messages := make([]ValidationMessage, 0)

    if err := validate(obj, messages); err != nil {
        return messages, err
    }

    return messages, nil
}

func validate(obj Validatable, accumulator []ValidationMessage) error {
    // If something is true, recurse
    if something {
        if err := validate(obj, accumulator); err != nil {
            return err
        }
    }

    // Append to the accumulator passed in
    accumulator = append(accumulator, message)

    return nil
}

上面的代码给出了与第一个示例相同的错误，因为 accumulator 没有获取所有附加值，因为它们只存在于函数的范围内。

为了解决这个问题，我将一个指针结构传递给函数，该结构包含累加器。该解决方案效果很好。

我的问题是，有没有更好的方法来做到这一点，我的方法是 Go 的惯用方法吗？

更新的解决方案（感谢 icza）：

我只是在递归函数中返回切片。这么大的脸，早该想到的。

func Validate(obj Validatable) ([]ValidationMessage, error) {
    messages := make([]ValidationMessage, 0)
    return validate(obj, messages)
}

func validate(obj Validatable, messages []ValidationMessage) ([]ValidationMessage, error) {
    err := v.Struct(obj)

    if _, ok := err.(*validator.InvalidValidationError); ok {
        return []ValidationMessage{}, errors.New(err.Error())
    }

    if _, ok := err.(validator.ValidationErrors); ok {
        messageMap := obj.Validate()

        for _, err := range err.(validator.ValidationErrors) {
            f := err.StructField()
            t := err.Tag()

            if v, ok := err.Value().(Validatable); ok {
                return validate(v, messages)
            } else if _, ok := messageMap[f]; ok {
                if _, ok := messageMap[f][t]; ok {
                    messages = append(messages, ValidationMessage(messageMap[f][t]))
                }
            }
        }
    }

    return messages, nil
}

Answer 1

如果要将切片作为参数传递给函数，并让该函数修改原始切片，则必须传递指向切片的指针：

func myAppend(list *[]string, value string) {
    *list = append(*list, value)
}

我不知道 Go 编译器在这方面是天真还是聪明；性能留给评论部分作为练习。

Answer 2

如果切片的当前大小不足以追加新值，则切片会根据需要动态增长，从而更改底层数组。如果未返回此新切片，则您的追加更改将不可见。

例子：

package main

import (
    "fmt"
)

func noReturn(a []int, data ...int) {
    a = append(a, data...)
}

func returnS(a []int, data ...int) []int {
    return append(a, data...)
}

func main() {
    a := make([]int, 1)
    noReturn(a, 1, 2, 3)
    fmt.Println(a) // append changes will not visible since slice size grew on demand changing underlying array

    a = returnS(a, 1, 2, 3)
    fmt.Println(a) // append changes will be visible here since your are returning the new updated slice
}

结果：

[0]
[0 1 2 3]

注意：

1. 如果您更新切片中的项目而不向切片添加新项目，则不必返回切片

Answer 3

您传递的切片是对数组的引用，这意味着大小是固定的。如果你只是修改了存储的值，没关系，值将在被调用函数之外更新。

但是如果你给切片添加了新元素，它会重新切片以容纳新元素，也就是说，会创建一个新切片，而旧切片不会被覆盖。

总结一下，如果需要对切片进行扩展或剪切，将指针传递给切片即可。否则，使用切片本身就足够了。

更新

---

我需要解释一些重要的事实。对于作为值传递给函数的切片添加新元素，有两种情况：

一个

底层数组达到了它的容量，创建了一个新的切片来替换原始切片，显然原始切片不会被修改。

B

底层数组未达到其容量，已被修改。 但是切片的字段len没有被覆盖，因为切片是按值传递的。因此，原始切片不会意识到其 len 已被修改，从而导致切片未被修改。

Answer 4

在向切片追加数据时，如果切片的底层数组空间不足，则会分配一个新数组。然后将旧数组中的元素复制到这个新内存中，并在后面添加新数据