如何确保slice使用的是另一个slice的副本，而不是对它的引用？

Question

我正在学习围棋，我有一个理论问题。

如何使用切片的副本而不是对其的引用？

package main

import "fmt"

func main() {
    // slice containing 3 items
    slice1 := []int{1, 2, 3}
    // make an empty slice
    slice2 := make([]int, 2, 5)
    // create slice3 by appending int 4 to slice2
    slice3 := append(slice2, 4)
    // print [0 0 4]
    fmt.Println(slice3)
    // copy elements of slice1 onto slice2
    copy(slice2, slice1)
    // print [1 2 3] [1 2] [1 2 4]; how to make sure slice3 is using a copy [0 0 4]?
    fmt.Println(slice1, slice2, slice3)
}

问题游乐场连接

我提出了一个可能的解决方案，但它毫无意义，因为它依赖于将切片3创建为空，并通过copy（）将切片2复制到切片3上。没有捷径吗？

package main

import "fmt"

func main() {
    // slice containing 3 items
    slice1 := []int{1, 2, 3}
    // make an empty slice
    slice2 := make([]int, 2, 5)
    // create slice3, copy slice2 and append int 4 to slice3
    slice3 := make([]int, 2)
    copy(slice3, slice2)
    slice3 = append(slice3, 4)
    // print [0 0 4]
    fmt.Println(slice3)
    // copy elements of slice1 onto slice2
    copy(slice2, slice1)
    // print [1 2 3] [1 2] [0 0 4];
    fmt.Println(slice1, slice2, slice3)
}

解决方案游乐场链接

编辑：

我已经读到，在这个天真的例子中，有一种特殊的行为可以作为解决方案（见下文）。然而，在任何其他情况下，这都是行不通的。基本上，如果创建空切片时没有指定底层数组的大小，GO的append函数将提供该数组的副本，否则，如果有增长空间，append将返回引用原始数组的切片。

注意：唯一的更改是将slice2:=make（[]int，2，5）更改为slice2:=make（[]int，2）

package main

import "fmt"

func main() {
    // slice containing 3 items
    slice1 := []int{1, 2, 3}
    // make an empty slice
    slice2 := make([]int, 2)
    // create slice3 by appending int 4 to slice2
    slice3 := append(slice2, 4)
    // print [0 0 4]
    fmt.Println(slice3)
    // copy elements of slice1 onto slice2
    copy(slice2, slice1)
    // print [1 2 3] [1 2] [1 2 4]; how to make sure slice3 is using a copy [0 0 4]?
    fmt.Println(slice1, slice2, slice3)
}

操场上有被通缉的行为

因此问题变成了：当我们附加到的切片指向具有指定大小和增长空间的数组时，是否有可能复制上述行为？

编辑2：我想对于我想要达到的目标有些困惑。如何在以第一次调用中使用的格式传递切片的同时获得第二次调用的结果？

package main

import "fmt"

func main() {
    fmt.Println("s3 references an array of s1")
    worker(make([]int, 2, 5))
    fmt.Println("\ns3 copies an array of s1")
    worker(make([]int, 2))
}

func worker(s1 []int) {
    s2 := []int{1, 2, 3}
    fmt.Println(s1)
    s3 := append(s1, 4)
    fmt.Println(s3)
    copy(s1, s2)
    fmt.Println(s3)
}

游戏场

Answer 1

有几个人评论说我昨晚不够清楚。因此，我想澄清并提供一个我在@CoreyOgburn和@JimB的帮助下得出的答案

我在学习GO中的切片时发现了不一致性，这让我相信我做错了什么。虽然这不是一个真实的示例，但我发现下面的示例是复制和附加功能的一个很好的示例。

package main

import "fmt"

func main() {
    fmt.Println("s3 references an array of s1")
// we pass a slice of length 2 and capacity 5
    worker(make([]int, 2, 5))
    fmt.Println("\ns3 copies an array of s1")
// we pass a slice of lenght 2 and capacity 2
    worker(make([]int, 2))
}

func worker(s1 []int) {
// create new slice for future use
    s2 := []int{1, 2, 3}
    fmt.Println(s1)
// create a new slice by appending a value to a slice passed into this function 
    s3 := append(s1, 4)
// s3 holds whatever was passed into this function + int 4, that we just appended
    fmt.Println(s3)
// copy contents of s2 onto s1
    copy(s1, s2)
// if s1 had spare capacity when it was passed i.e. make([]int, 2, 5) s3 will be referencing the same array as s1, hence s3 will now hold the same values as s1
// if s1 capacity was the same as its length i.e. make([]int, 2) s3 will be referencing a new array after append(), hence copy has no effect on the values of s3
    fmt.Println(s3)
} 

@JimB发表了一篇评论，链接到一篇博客文章，解释了切片是如何工作的，如果你正在学习这门语言，这是一篇很好的文章。在一节中最重要的是一个可能的“明白”有一个对现实生活场景的“修复”的解释，可以推断为修复我的例子中的不一致性。（创建一个传递的切片的副本，并使用取而代之的是）
游乐场