Fatal编程技术网
  • go/
  • Go 复制功能是如何工作的？

Go 复制功能是如何工作的？

go

Go 复制功能是如何工作的？,go,copy,slice,Go,Copy,Slice,我不理解基于文档的复制功能是如何工作的： copy内置函数将元素从源片复制到源片中 目标片。（作为特例，它还将从 源和目标可能重叠。复制 返回复制的元素数，该数为 len（src）和len（dst） 以下是如何使用内置复制功能的基本示例： // The source slice source := []int{1, 2, 3,} // The destination slice is where things will be copied to destination := make([]in

我不理解基于文档的
复制
功能是如何工作的：

copy内置函数将元素从源片复制到源片中 目标片。（作为特例，它还将从 源和目标可能重叠。复制 返回复制的元素数，该数为 len（src）和len（dst）

以下是如何使用内置复制功能的基本示例：

// The source slice
source := []int{1, 2, 3,}

// The destination slice is where things will be copied to
destination := make([]int, len(source))

// The copy function returns a count of how many elements are copied from the source slice to the destination slice
copies := copy(destination, source)

// Some printing
fmt.Printf("copied %d elements\n", copies)  // Outputs: copied 3 elements
fmt.Println("destination slice:", destination)  // Outputs: destination slice: [1 2 3]

如果
目标
片的长度为
n
，而
源
片的长度为
m
，并且
n
m
则目标片将填充
源
片的第一个
n
元素：

source := []int{1, 2, 3,}
destination := make([]int, 1) // <-- Notice the 1
copies := copy(destination, source)
fmt.Printf("copied %d elements\n", copies)  // Outputs: copied 1 elements
fmt.Println("destination slice:", destination)  // Outputs: destination slice: [1]
长度为0，不会复制任何内容。

以下是如何使用内置复制功能的基本示例：

// The source slice
source := []int{1, 2, 3,}

// The destination slice is where things will be copied to
destination := make([]int, len(source))

// The copy function returns a count of how many elements are copied from the source slice to the destination slice
copies := copy(destination, source)

// Some printing
fmt.Printf("copied %d elements\n", copies)  // Outputs: copied 3 elements
fmt.Println("destination slice:", destination)  // Outputs: destination slice: [1 2 3]

如果
目标
片的长度为
n
，而
源
片的长度为
m
，并且
n
m
则目标片将填充
源
片的第一个
n
元素：

source := []int{1, 2, 3,}
destination := make([]int, 1) // <-- Notice the 1
copies := copy(destination, source)
fmt.Printf("copied %d elements\n", copies)  // Outputs: copied 1 elements
fmt.Println("destination slice:", destination)  // Outputs: destination slice: [1]
长度将为0，不会复制任何内容。

规范还包括内置函数
append（）
和
copy（）
：。你应该读一下，很清楚

让我们用简单的例子来分析内置函数的doc及其用法。你可以在网上试试所有的例子

签名：

func copy(dst, src []Type) int

copy（）
是一个函数，它有两个参数，一个目标片和一个源片，其元素类型相同。它返回类型
int
的数量，即实际复制的元素数量

copy内置函数将元素从源片复制到目标片

copy（）
将元素从
src
切片复制到
dst
切片中

src := []int{10, 11, 12, 13, 14}
dst := []int{0, 1, 2, 3, 4}

n := copy(dst, src)
fmt.Println("n =", n, "src =", src, "dst =", dst)
输出：

n = 5 src = [10 11 12 13 14] dst = [10 11 12 13 14]

n = 2 src = [10 11 12 13 14] dst = [10 11]

n = 2 src = [10 11] dst = [10 11 2 3 4]

n = 5 str = Hello World! data = [72 101 108 108 111]
data as string: Hello

n = 4 src = [1 2 3 4 4]
它复制了所有5个元素，复制后目标元素与源元素相同

让我们继续这个例子：

dst = []int{0, 1}

n = copy(dst, src)
fmt.Println("n =", n, "src =", src, "dst =", dst)
输出：

n = 5 src = [10 11 12 13 14] dst = [10 11 12 13 14]

n = 2 src = [10 11 12 13 14] dst = [10 11]

n = 2 src = [10 11] dst = [10 11 2 3 4]

n = 5 str = Hello World! data = [72 101 108 108 111]
data as string: Hello

n = 4 src = [1 2 3 4 4]
仅复制了2个元素，因为目标只有2个元素

继续：

src = []int{10, 11}
dst = []int{0, 1, 2, 3, 4}

n = copy(dst, src)
fmt.Println("n =", n, "src =", src, "dst =", dst)
输出：

n = 5 src = [10 11 12 13 14] dst = [10 11 12 13 14]

n = 2 src = [10 11 12 13 14] dst = [10 11]

n = 2 src = [10 11] dst = [10 11 2 3 4]

n = 5 str = Hello World! data = [72 101 108 108 111]
data as string: Hello

n = 4 src = [1 2 3 4 4]
同样，只复制了2个元素，但这次是因为源只有2个元素

因此，
copy（）
将只复制源或目标的元素数量，以较小的为准。或者换句话说，只要来源“提供”或目的地可以“容纳”，以较小者为准

（作为一种特殊情况，它还会将字节从字符串复制到字节片。）

这意味着如果目标是
[]字节
，则源也可以是
字符串
：

str := "Hello World!"
data := make([]byte, 5)
n = copy(data, str)
fmt.Println("n =", n, "str =", str, "data =", data)
fmt.Printf("data as string: %s\n", data)
输出：

n = 5 src = [10 11 12 13 14] dst = [10 11 12 13 14]

n = 2 src = [10 11 12 13 14] dst = [10 11]

n = 2 src = [10 11] dst = [10 11 2 3 4]

n = 5 str = Hello World! data = [72 101 108 108 111]
data as string: Hello

n = 4 src = [1 2 3 4 4]
这次源是一个
字符串
，
copy（）
复制了
字符串
的UTF-8表示的5个字节（这是Go在内存中存储字符串的方式）

源和目标可能重叠

这意味着
copy（）
工作正常，即使目标是与源片共享相同底层数组的片，并且由源和目标指定的数组部分具有公共部分（重叠）

例如：

copy(src, src[1:])
fmt.Println("n =", n, "src =", src)
输出：

n = 5 src = [10 11 12 13 14] dst = [10 11 12 13 14]

n = 2 src = [10 11 12 13 14] dst = [10 11]

n = 2 src = [10 11] dst = [10 11 2 3 4]

n = 5 str = Hello World! data = [72 101 108 108 111]
data as string: Hello

n = 4 src = [1 2 3 4 4]
这里我指定了
src[1:://code>作为源代码，它是没有第一个元素的源代码（这是一个数组）。因为我排除了第一个元素，所以
copy（）
的源有4个元素，所以
4个
元素被复制。结果是元素被“移位”到一个小于1的索引（因此第一个
0
的元素现在从切片中消失），最后一个元素没有被触摸（因为只复制了4个元素）

Copy返回复制的元素数，它是len（src）和len（dst）中的最小值

我们已经在上面的例子中看到了这一点

如果您需要了解有关切片的更多信息：




该规范还涵盖了内置函数
append（）
和
copy（）
：。你应该读一下，很清楚

让我们用简单的例子来分析内置函数的doc及其用法。你可以在网上试试所有的例子

签名：


func copy(dst, src []Type) int



copy（）
是一个函数，它有两个参数，一个目标片和一个源片，其元素类型相同。它返回类型
int
的数量，即实际复制的元素数量

copy内置函数将元素从源片复制到目标片


copy（）
将元素从
src
切片复制到
dst
切片中


src := []int{10, 11, 12, 13, 14}
dst := []int{0, 1, 2, 3, 4}

n := copy(dst, src)
fmt.Println("n =", n, "src =", src, "dst =", dst)


输出：


n = 5 src = [10 11 12 13 14] dst = [10 11 12 13 14]



n = 2 src = [10 11 12 13 14] dst = [10 11]



n = 2 src = [10 11] dst = [10 11 2 3 4]



n = 5 str = Hello World! data = [72 101 108 108 111]
data as string: Hello



n = 4 src = [1 2 3 4 4]


它复制了所有5个元素，复制后目标元素与源元素相同

让我们继续这个例子：


dst = []int{0, 1}

n = copy(dst, src)
fmt.Println("n =", n, "src =", src, "dst =", dst)


输出：


n = 5 src = [10 11 12 13 14] dst = [10 11 12 13 14]



n = 2 src = [10 11 12 13 14] dst = [10 11]



n = 2 src = [10 11] dst = [10 11 2 3 4]



n = 5 str = Hello World! data = [72 101 108 108 111]
data as string: Hello



n = 4 src = [1 2 3 4 4]


仅复制了2个元素，因为目标只有2个元素

继续：


src = []int{10, 11}
dst = []int{0, 1, 2, 3, 4}

n = copy(dst, src)
fmt.Println("n =", n, "src =", src, "dst =", dst)


输出：


n = 5 src = [10 11 12 13 14] dst = [10 11 12 13 14]



n = 2 src = [10 11 12 13 14] dst = [10 11]



n = 2 src = [10 11] dst = [10 11 2 3 4]



n = 5 str = Hello World! data = [72 101 108 108 111]
data as string: Hello



n = 4 src = [1 2 3 4 4]


同样，只复制了2个元素，但这次是因为源只有2个元素

因此，
copy（）
将只复制源或目标的元素数量，以较小的为准。或者换句话说，只要来源“提供”或目的地可以“容纳”，以较小者为准

（作为一种特殊情况，它还会将字节从字符串复制到字节片。）

这意味着如果目标是
[]字节
，则源也可以是
字符串
：


str := "Hello World!"
data := make([]byte, 5)
n = copy(data, str)
fmt.Println("n =", n, "str =", str, "data =", data)
fmt.Printf("data as string: %s\n", data)


输出：


n = 5 src = [10 11 12 13 14] dst = [10 11 12 13 14]



n = 2 src = [10 11 12 13 14] dst = [10 11]



n = 2 src = [10 11] dst = [10 11 2 3 4]



n = 5 str = Hello World! data = [72 101 108 108 111]
data as string: Hello



n = 4 src = [1 2 3 4 4]


这次源是一个
字符串
，
copy（）
复制了
字符串
的UTF-8表示的5个字节（这是Go在内存中存储字符串的方式）

源和目标可能重叠

这意味着
copy（）
工作正常，即使目标是与源片共享相同底层数组的片，以及由source和dest指定的数组部分