为什么我不能复制与拷贝`（）`分得一杯羹？

Question

我需要在围棋片的拷贝和读取文档有我的处置copy功能。

复制内建从片源拷贝功能的元素融入到目标切片。 （作为一种特殊情况，它也将从一个字符串的字节切片复制字节。）的源和目的地可以重叠。拷贝返回复制的元素的数目，这将是LEN（SRC）和len（DST）的最小值。

但是，当我这样做：

arr := []int{1, 2, 3}
tmp := []int{}
copy(tmp, arr)
fmt.Println(tmp)
fmt.Println(arr)

我tmp是空的，因为它以前（我甚至尝试使用arr, tmp）：

[]
[1 2 3]

你可以检查一下就走playground。那么，为什么我不能复制分得一杯羹？

Answer 1

内置的qazxsw POI副本qazxsw POI元素。

所以，如果你copy(dst, src)是空的（min(len(dst), len(src))），什么都不会被复制。

尝试dst（len(dst) == 0）：

tmp := make([]int, len(arr))

输出（如预期）：

Go Playground

不幸的是，这是不是在

arr := []int{1, 2, 3}
tmp := make([]int, len(arr))
copy(tmp, arr)
fmt.Println(tmp)
fmt.Println(arr)

包记录，但它是在

[1 2 3]
[1 2 3]

记载：

复制的元素的数目是builtin和Go Language Specification: Appending to and copying slices的最小值。

编辑：

最后len(src)的文档已经更新，它现在包含一个事实，即源和目的地的最小长度将被复制：

拷贝返回复制的元素的数目，这将是LEN（SRC）和len（DST）的最小值。

Answer 2

另一种简单的方式做，这是通过使用len(dst)将在分配过程中分得一杯羹。

copy()

输出（如预期）：

append

因此，对于复制阵列的缩写

arr := []int{1, 2, 3}
tmp := append([]int(nil), arr...)  // Notice the ... splat
fmt.Println(tmp)
fmt.Println(arr)

将

[1 2 3]
[1 2 3]

arr

Answer 3

如果你的片大小相同的，append([]int(nil), arr...)：

https://play.golang.org/p/sr_4ofs5GW

将给：

it would work

从 “

arr := []int{1, 2, 3}
tmp := []int{0, 0, 0}
i := copy(tmp, arr)
fmt.Println(i)
fmt.Println(tmp)
fmt.Println(arr)

”：

复印功能支持不同长度的片段之间的复制（它将仅复制到元件的较小的数字）

通常的例子是：

3
[1 2 3]
[1 2 3]

Answer 4

副本（）的DST和src的长度至少运行，所以你必须初始化DST所需的长度。

Go Slices: usage and internals

输出：

t := make([]byte, len(s), (cap(s)+1)*2)
copy(t, s)
s = t

您可以初始化并使用append（），以一比零切片复制所有元素在同一行。

A := []int{1, 2, 3}
B := make([]int, 3)
copy(B, A)
C := make([]int, 2)
copy(C, A)
fmt.Println(A, B, C)

例：

[1 2 3] [1 2 3] [1 2]

输出：

x := append([]T{}, []...)

与分配+拷贝（）比较，为大于1,000的元件，使用追加。其实波纹管1000的差别可以忽略，使其成为经验法则一去，除非你有很多片。

A := []int{1, 2, 3}
B := append([]int{}, A...)
C := append([]int{}, A[:2]...)
fmt.Println(A, B, C)    

Answer 5

[1 2 3] [1 2 3] [1 2]

BenchmarkCopy1-4                50000000            27.0 ns/op
BenchmarkCopy10-4               30000000            53.3 ns/op
BenchmarkCopy100-4              10000000           229 ns/op
BenchmarkCopy1000-4              1000000          1942 ns/op
BenchmarkCopy10000-4              100000         18009 ns/op
BenchmarkCopy100000-4              10000        220113 ns/op
BenchmarkCopy1000000-4              1000       2028157 ns/op
BenchmarkCopy10000000-4              100      15323924 ns/op
BenchmarkCopy100000000-4               1    1200488116 ns/op
BenchmarkAppend1-4              50000000            34.2 ns/op
BenchmarkAppend10-4             20000000            60.0 ns/op
BenchmarkAppend100-4             5000000           240 ns/op
BenchmarkAppend1000-4            1000000          1832 ns/op
BenchmarkAppend10000-4            100000         13378 ns/op
BenchmarkAppend100000-4            10000        142397 ns/op
BenchmarkAppend1000000-4            2000       1053891 ns/op
BenchmarkAppend10000000-4            200       9500541 ns/op
BenchmarkAppend100000000-4            20     176361861 ns/op

功能复制拷贝切片从源SRC到目的地DST元素，并返回复制的元素的数量。这两个参数必须具有相同的元件类型T，并且必须分配给类型[] T的切片。复制的元素的数目为LEN（SRC）和len（DST）的最小值。作为一种特殊的情况下，复制也接受目的地参数分配与字符串类型的源参数输入[]字节。这种形式复制字符串中的字节到字节片。

The Go Programming Language Specification

Appending to and copying slices需要足够的空间

copy(dst, src []T) int
copy(dst []byte, src string) int

。例如，

tmp

输出：

arr