append生成新变量的时候，没有如预期（It's a feature，not a bug？）

Question

这是我在写一个项目中，遇到的一个golang的feature，如代码所示，我在for循环里，每次用append生成一个新的数组，（当然我以前一直以为可以这样，直到我在stackoverflow上发现不能。）然后将这个数组追加到一个大数组里（二维数组），这时候发现并不如预期那样，似乎每次append没有返回新数组，然而，当我把一开始生成的5修改为2的时候，却是正常的，如果都不正常也好理解，有时正常有时不正常的行为难以琢磨，请懂go底层实现的大牛牛们解释一下为啥会这样呢？
stackoverflow上类似的问题是：

http://stackoverflow.com/ques...

基本上和我的差不多，最后我也是使用答案中建议的方式copy来解决的。

package main

import (
    "fmt"
)

func main() {
    arr := make([]int, 0)
    for i := 0; i < 5; i++ { // 如果将此处的 5 修改为 2，可以看到 [0 1 0] [0 1 1] 运行如预期
        arr = append(arr, i)
    }

    var list [][]int
    for _, v := range arr {
        vi := append(arr, v)
        fmt.Println(vi)
        /*
         * 注意此处的vi依次为
         *     [0 1 2 3 4 0]
         *    [0 1 2 3 4 1]
         *    [0 1 2 3 4 2]
         *    [0 1 2 3 4 3]
         *    [0 1 2 3 4 4]
         */
        // 但是追加进去后，末尾的最后一位全部变成了4
        list = append(list, vi)
    }
    fmt.Println(list)
    // 最后的list 却为：
    /**
     * [
     *    [0 1 2 3 4 4]
     *    [0 1 2 3 4 4]
     *    [0 1 2 3 4 4]
     *    [0 1 2 3 4 4]
     *    [0 1 2 3 4 4] ]
     *
     * 看起来，似乎go在底层每次使用的是同一个vi，并且vi最后被修改成了最后一次的值4. 鹅妹子嘤！
     **/
}

运行结果地址：

https://wide.b3log.org/playgr...

将5修改为2后：

https://wide.b3log.org/playgr...

Answer 1

你要区分数组和切片类型，说白点，切片就是对数组的引用。append是对一个切片引用的数组后追加数据，如果原数组有足够大的空间能容纳新数据，那么append会返回一个新切片但引用的还是旧数组，如果原数组的空间不足以容纳新数据，那么go会将底层数组深拷贝一份并返回新切片。

package main

import (
    "fmt"
)

func main() {
    arr := make([]int, 0)
    for i := 0; i < 5; i++ {
        arr = append(arr, i)
    }
    fmt.Printf("arr = %v, cap = %d\n", arr, cap(arr))
    // 循环结束后arr cap已经到8了

    var list [][]int
    for _, v := range arr {
        vi := append(arr, v)
        // v = 0 | arr len = 5, cap = 8 | vi len = 6, cap = 8, Data = {0,1,2,3,4,x,x,x} + 0 = {0,1,2,3,4,0,x,x}
        // v = 1 | arr len = 5, cap = 8 | vi len = 6, cap = 8, Data = {0,1,2,3,4,x,x,x} + 1 = {0,1,2,3,4,1,x,x}
        // v = 2 | arr len = 5, cap = 8 | vi len = 6, cap = 8, Data = {0,1,2,3,4,x,x,x} + 2 = {0,1,2,3,4,2,x,x}
        // v = 3 | arr len = 5, cap = 8 | vi len = 6, cap = 8, Data = {0,1,2,3,4,x,x,x} + 3 = {0,1,2,3,4,3,x,x}
        // v = 4 | arr len = 5, cap = 8 | vi len = 6, cap = 8, Data = {0,1,2,3,4,x,x,x} + 4 = {0,1,2,3,4,4,x,x}

        list = append(list, vi)
        // list cap = 1, Data = [[0,1,2,3,4,0]]
        // list cap = 2, Data = [[0,1,2,3,4,1], [0,1,2,3,4,1]]
        // list cap = 4, Data = [[0,1,2,3,4,2], [0,1,2,3,4,2], [0,1,2,3,4,2]]
        // list cap = 4, Data = [[0,1,2,3,4,3], [0,1,2,3,4,3], [0,1,2,3,4,3], [0,1,2,3,4,3]]
        // list cap = 8, Data = [[0,1,2,3,4,4], [0,1,2,3,4,4], [0,1,2,3,4,4], [0,1,2,3,4,4], [0,1,2,3,4,4]]
        fmt.Printf("list = %v, cap = %d\n", list, cap(list))
    }
}

第一个循环结束后，arr容量到8了，足够容纳数据，所以在第二个循环中生成vi时，总是返回对arr底层数据的引用。我想你的误区就在这里，你以为生成的是新数组vi，然而每次循环只是在修改原始arr的末尾数据，然后返回一个arr的切片而已，循环最后一次修改的数据是[0,1,2,3,4,4]，所以最终list中所有切片元素指向的数组都是它。

如果想达到你的预期目的，就需要进行深拷贝，使用copy方法

package main

import (
    "fmt"
)

func main() {
    arr := make([]int, 0)
    for i := 0; i < 5; i++ {
        arr = append(arr, i)
    }
    fmt.Printf("arr = %v, cap = %d\n", arr, cap(arr))

    var list [][]int
    for _, v := range arr {
        vi := append(arr, v)

        // 这里进行深拷贝
        z := make([]int, len(vi))
        copy(z, vi)

        list = append(list, z)
        fmt.Printf("list = %v, cap = %d\n", list, cap(list))
    }
}

把这一章节读读http://docs.plhwin.com/gopl-z...