英文:
Why can't I duplicate a slice with `copy()`?
问题
我需要在Go语言中复制一个切片,并且在阅读文档时发现有一个可用的copy函数。
copy内置函数将源切片的元素复制到目标切片中。(作为特例,它还可以将字符串的字节复制到字节切片中。)源和目标可能重叠。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]
你可以在Go playground上检查它。那么为什么我不能复制一个切片呢?
英文:
I need to make a copy of a slice in Go and reading the docs there is a copy function at my disposal.
> The copy built-in function copies elements from a source slice into a
> destination slice. (As a special case, it also will copy bytes from a
> string to a slice of bytes.) The source and destination may overlap.
> Copy returns the number of elements copied, which will be the minimum
> of len(src) and len(dst).
But when I do:
arr := []int{1, 2, 3}
tmp := []int{}
copy(tmp, arr)
fmt.Println(tmp)
fmt.Println(arr)
My tmp
is empty as it was before (I even tried to use arr, tmp
):
[]
[1 2 3]
You can check it on go playground. So why can not I copy a slice?
答案1
得分: 320
内置函数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语言规范:向切片追加和复制中有记录:
> 复制的元素数量是len(src)
和len(dst)
中的最小值。
编辑:
最终copy()
函数的文档已经更新,现在包含了源和目标最小长度被复制的事实:
> Copy返回被复制的元素数量,这个数量将是len(src)
和len(dst)
中的最小值。
英文:
The builtin copy(dst, src)
copies min(len(dst), len(src))
elements.
So if your dst
is empty (len(dst) == 0
), nothing will be copied.
Try 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)
Output (as expected):
[1 2 3]
[1 2 3]
Unfortunately this is not documented in the builtin
package, but it is documented in the Go Language Specification: Appending to and copying slices:
> The number of elements copied is the minimum of len(src)
and len(dst)
.
Edit:
Finally the documentation of copy()
has been updated and it now contains the fact that the minimum length of source and destination will be copied:
> Copy returns the number of elements copied, which will be the minimum of len(src) and len(dst).
答案2
得分: 52
另一种简单的方法是使用append
函数来分配切片的空间。
arr := []int{1, 2, 3}
tmp := append([]int(nil), arr...) // 注意这里的...操作符
fmt.Println(tmp)
fmt.Println(arr)
输出结果(如预期):
[1 2 3]
[1 2 3]
正如下面的评论所指出的,如果切片的大小没有正确设置,append
函数可能会分配多余的内存。解决这个问题的一个好方法是预先分配一个具有正确容量的切片,如下所示:
tmp := append(make([]int, 0, len(arr)), arr...)
因此,复制数组arr
的简写方式就是append(make([]int, 0, len(arr)), arr...)
。
链接:https://play.golang.org/p/xwevI1chGrd
英文:
Another simple way to do this is by using append
which will allocate the slice in the process.
arr := []int{1, 2, 3}
tmp := append([]int(nil), arr...) // Notice the ... splat
fmt.Println(tmp)
fmt.Println(arr)
Output (as expected):
[1 2 3]
[1 2 3]
As pointed out in the comments below, append
may allocate excess memory if the slice isn't sized correctly to begin with. A nice solution to this is to preallocate a slice of the right capacity, like so:
tmp := append(make([]int, 0, len(arr)), arr...)
So a shorthand for copying array arr
would be append(make([]int, 0, len(arr)), arr...)
答案3
得分: 13
copy()函数的运行长度取决于目标(dst)和源(src)的最小长度,因此您必须将目标(dst)初始化为所需的长度。
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]
您可以使用append()函数将所有元素初始化并复制到一个空切片中。
x := append([]T{}, []...)
示例:
A := []int{1, 2, 3}
B := append([]int{}, A...)
C := append([]int{}, A[:2]...)
fmt.Println(A, B, C)
输出结果:
[1 2 3] [1 2 3] [1 2]
与分配+复制(allocation+copy())相比,对于大于1,000个元素的情况,使用append()函数。实际上,在1,000以下的情况下,差异可能可以忽略不计,除非您有很多切片。
以下是一些基准测试的结果:
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
英文:
The copy() runs for the least length of dst and src, so you must initialize the dst to the desired length.
A := []int{1, 2, 3}
B := make([]int, 3)
copy(B, A)
C := make([]int, 2)
copy(C, A)
fmt.Println(A, B, C)
Output:
[1 2 3] [1 2 3] [1 2]
You can initialize and copy all elements in one line using append() to a nil slice.
x := append([]T{}, []...)
Example:
A := []int{1, 2, 3}
B := append([]int{}, A...)
C := append([]int{}, A[:2]...)
fmt.Println(A, B, C)
Output:
[1 2 3] [1 2 3] [1 2]
Comparing with allocation+copy(), for greater than 1,000 elements, use append. Actually bellow 1,000 the difference may be neglected, make it a go for rule of thumb unless you have many slices.
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
答案4
得分: 12
如果你的切片大小相同,它将起作用:
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]
来自"Go切片:用法和内部原理":
copy函数支持在不同长度的切片之间进行复制(它只会复制到较小的元素数量)
通常的例子是:
t := make([]byte, len(s), (cap(s)+1)*2)
copy(t, s)
s = t
英文:
If your slices were of the same size, 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)
Would give:
3
[1 2 3]
[1 2 3]
From "Go Slices: usage and internals":
> The copy function supports copying between slices of different lengths (it will copy only up to the smaller number of elements)
The usual example is:
t := make([]byte, len(s), (cap(s)+1)*2)
copy(t, s)
s = t
答案5
得分: 12
最佳的切片克隆方法是:
sClone = append(s[:0:0], s...)
这种实现方式有两个优点:
-
确保如果 s 为 nil,则结果 sClone 也为 nil;如果 s 不为 nil,则 sClone 不为 nil。
-
即使类型 T 声明在另一个包中,也无需导入 T 所在的包。
英文:
The best way to clone as slice is
sClone = append(s[:0:0], s...)
This implementation has two advantage:
-
make sure that the result sClone is nil if s is nil, and is not nil
if s is not nil. -
No need to import the containing package of type T even if T is declared in
another package
答案6
得分: 2
《Go编程语言规范》
追加和复制切片
函数copy将源切片src的元素复制到目标切片dst,并返回复制的元素数量。两个参数必须具有相同的元素类型T,并且必须可分配给类型[]T的切片。复制的元素数量是len(src)和len(dst)中的最小值。作为特例,copy还接受一个目标参数,可分配给类型[]byte,并且源参数是字符串类型。这种形式将字符串中的字节复制到字节切片中。
copy(dst, src []T) int
copy(dst []byte, src string) int
tmp
需要足够的空间来存储arr
。例如,
package main
import "fmt"
func main() {
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]
英文:
> The Go Programming Language Specification
>
> Appending to and copying slices
>
> The function copy copies slice elements from a source src to a
> destination dst and returns the number of elements copied. Both
> arguments must have identical element type T and must be assignable to
> a slice of type []T. The number of elements copied is the minimum of
> len(src) and len(dst). As a special case, copy also accepts a
> destination argument assignable to type []byte with a source argument
> of a string type. This form copies the bytes from the string into the
> byte slice.
>
> copy(dst, src []T) int
> copy(dst []byte, src string) int
tmp
needs enough room for arr
. For example,
package main
import "fmt"
func main() {
arr := []int{1, 2, 3}
tmp := make([]int, len(arr))
copy(tmp, arr)
fmt.Println(tmp)
fmt.Println(arr)
}
Output:
[1 2 3]
[1 2 3]
答案7
得分: 2
如果您不关心速度:
import "golang.org/x/exp/slices"
tmp := slices.Clone(arr)
使用Go 1.18和泛型,现在可以使用golang.org/x/exp/slices
包中的slices.Clone
函数来复制任何切片。Playground
英文:
If you don't care about the speed:
import "golang.org/x/exp/slices"
tmp := slices.Clone(arr)
With Go 1.18 and generics, any slices now could be copied with slices.Clone
from package "golang.org/x/exp/slices"
. Playground
答案8
得分: 1
甜美、简单、高效,无需担心长度,无内存重叠,不同的副本
slice2 := append([]int{}, slice1...)
英文:
Sweet, Simple, Performant, No need to be careful of length, No Memory overlap, Different copies
slice2 := append([]int{}, slice1...)
答案9
得分: 0
> **注意:**这是一个错误的解决方案,正如@benlemasurier证明的那样。
这是一种复制切片的方法。我有点晚了,但是比@Dave的答案更简单、更快。这个是从类似@Dave的代码生成的指令。这些是由我的代码生成的指令。你可以看到指令要少得多。它所做的就是执行append(slice)
,这样就复制了切片。这段代码:
package main
import "fmt"
func main() {
var foo = []int{1, 2, 3, 4, 5}
fmt.Println("foo:", foo)
var bar = append(foo)
fmt.Println("bar:", bar)
bar = append(bar, 6)
fmt.Println("foo after:", foo)
fmt.Println("bar after:", bar)
}
输出结果为:
foo: [1 2 3 4 5]
bar: [1 2 3 4 5]
foo after: [1 2 3 4 5]
bar after: [1 2 3 4 5 6]
英文:
> NOTE: This is an incorrect solution as @benlemasurier proved
Here is a way to copy a slice. I'm a bit late, but there is a simpler, and faster answer than @Dave's. This are the instructions generated from a code like @Dave's. These is the instructions generated by mine. As you can see there are far fewer instructions. What is does is it just does append(slice)
, which copies the slice. This code:
package main
import "fmt"
func main() {
var foo = []int{1, 2, 3, 4, 5}
fmt.Println("foo:", foo)
var bar = append(foo)
fmt.Println("bar:", bar)
bar = append(bar, 6)
fmt.Println("foo after:", foo)
fmt.Println("bar after:", bar)
}
Outputs this:
foo: [1 2 3 4 5]
bar: [1 2 3 4 5]
foo after: [1 2 3 4 5]
bar after: [1 2 3 4 5 6]
答案10
得分: 0
只需对实现切片复制的这三种方法进行基准测试:
- 在
CloneWithAppend
中使用append
- 在
CloneWithCopy
中使用copy
- 在
CloneWithAny
中使用通用的any
和append
func CloneWithAppend(b []byte) []byte {
if b == nil {
return nil
}
return append([]byte{}, b...)
}
func CloneWithCopy(b []byte) []byte {
if b == nil {
return nil
}
tmp := make([]byte, len(b))
copy(tmp, b)
return tmp
}
func CloneWithAny[B ~[]T, T any](b B) B {
if b == nil {
return nil
}
return append([]T{}, b...)
}
基准测试代码
var testSlice = []byte("qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM098765432112345678901234567890")
func BenchmarkCloneWithAppend(b *testing.B) {
for i := 0; i < b.N; i++ {
CloneWithAppend(testSlice)
}
}
func BenchmarkCloneWithCopy(b *testing.B) {
for i := 0; i < b.N; i++ {
CloneWithCopy(testSlice)
}
}
func BenchmarkCloneWithAny(b *testing.B) {
for i := 0; i < b.N; i++ {
CloneWithAny(testSlice)
}
}
结果
goarch: amd64
pkg: test
cpu: Intel(R) Core(TM) i7-8850H CPU @ 2.60GHz
BenchmarkCloneWithAppend-12 28700232 41.50 ns/op
BenchmarkCloneWithCopy-12 32453222 30.98 ns/op
BenchmarkCloneWithAny-12 31737926 41.68 ns/op
看起来使用copy
方法的性能更好。
注意,根据这个提交和相关提案bytes, strings: add Clone,在下一个Golang版本中将添加bytes
包中的func Clone([]uint8) []uint8
。
// Clone返回b[:len(b)]的副本。
// 结果可能有额外的未使用容量。
// Clone(nil)返回nil。
func Clone(b []byte) []byte {
if b == nil {
return nil
}
return append([]byte{}, b...)
}
英文:
Just do benchmark for those three methods which implement slice copy
- with
append
onCloneWithAppend
- with
copy
onCloneWithCopy
- with
append
for genericany
onCloneWithAny
func CloneWithAppend(b []byte) []byte {
if b == nil {
return nil
}
return append([]byte{}, b...)
}
func CloneWithCopy(b []byte) []byte {
if b == nil {
return nil
}
tmp := make([]byte, len(b))
copy(tmp, b)
return tmp
}
func CloneWithAny[B ~[]T, T any](b B) B {
if b == nil {
return nil
}
return append([]T{}, b...)
}
Benchmark codes
var testSlice = []byte("qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM098765432112345678901234567890")
func BenchmarkCloneWithAppend(b *testing.B) {
for i := 0; i < b.N; i++ {
CloneWithAppend(testSlice)
}
}
func BenchmarkCloneWithCopy(b *testing.B) {
for i := 0; i < b.N; i++ {
CloneWithCopy(testSlice)
}
}
func BenchmarkCloneWithAny(b *testing.B) {
for i := 0; i < b.N; i++ {
CloneWithAny(testSlice)
}
}
Results
goarch: amd64
pkg: test
cpu: Intel(R) Core(TM) i7-8850H CPU @ 2.60GHz
BenchmarkCloneWithAppend-12 28700232 41.50 ns/op
BenchmarkCloneWithCopy-12 32453222 30.98 ns/op
BenchmarkCloneWithAny-12 31737926 41.68 ns/op
It seems the with copy
method has better performance.
Note, func Clone([]uint8) []uint8
of pkg bytes
would be added in Golang next release per this commit and related proposal bytes, strings: add Clone
// Clone returns a copy of b[:len(b)].
// The result may have additional unused capacity.
// Clone(nil) returns nil.
func Clone(b []byte) []byte {
if b == nil {
return nil
}
return append([]byte{}, b...)
}
答案11
得分: 0
感谢回答者,如果有人需要复制多个列表,这个通用方法可能会有所帮助(正如在文档中所说,Go 从 1.18 版本开始引入了对泛型的本地支持):
func CopyList[T any](list []T) []T {
newList := make([]T, len(list))
copy(newList, list)
return newList
}
用法:copiedList := CopyList(originalList)
英文:
Thanks to the answerers, if someone needs to copy many lists, this generic method may helps (As said in the documentation, Go introduced native support for generics starting from version 1.18) :
func CopyList[T any](list []T) []T {
newList := make([]T, len(list))
copy(newList, list)
return newList
}
usage : copiedList := CopyList(originalList)
通过集体智慧和协作来改善编程学习和解决问题的方式。致力于成为全球开发者共同参与的知识库,让每个人都能够通过互相帮助和分享经验来进步。
评论