copy(dst, src []Type) int

  1. copy 内置函数将元素从 src 源切片复制到 dst 目标切片。(作为一种特殊情况，它还将字节从一个 string 复制到一个 []byte)
  2. src 和 dst 可能会重叠。copy 返回赋值的元素数量，它将是 len(src) 和 len(dst) 的最小值。
    • 常常将切片元素从源src复制到目标dst，并返回复制的元素数
    • 两个参数必须具有相同得元素类型Type，并且可以分配给类型为[]Type的切片
    • src和dst切片的底层元素可能会重叠
    • 复制的元素数量是len(src)和len(dst)的最小值
1
2
3
4
5
6

// 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).
copy(dst, src []Type) int   // src -> dst
  1. 使用示例。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

func ExampleCopy() {
    var a = [...]int{0,1,2,3,4,5,6,7}
    var s = make([]int, 6)

    n1 := copy(s, a[0:])
    fmt.Println(n1, s)      // 6    [0 1 2 3 4 5]

    // 从s中赋值数据到s中    
    n2 := copy(s, s[2:])
    fmt.Println(n2, s)      // 4    [2 3 4 5 4 5]
    
    fmt.Println(a)          // [0 1 2 3 4 5 6 7]
    
    // Output:
    // 6 [0 1 2 3 4 5]
    // 4 [2 3 4 5 4 5]
    // [0 1 2 3 4 5 6 7]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

func ExampleCopy() {
    var a = [...]int{0,1,2,3,4,5,6,7}
    var s = make([]int, 4)

    n1 := copy(s, a[0:])
    fmt.Println(n1, s)      // 4   [0 1 2 3]

    // 从s中赋值数据到s中  
    n2 := copy(s, s[2:])
    fmt.Println(n2, s)      // 2   [2 3 2 3]
    
    fmt.Println(a)          // [0 1 2 3 4 5 6 7]
    
    // Output:
    // 4 [0 1 2 3]
    // 2 [2 3 2 3]
    // [0 1 2 3 4 5 6 7]
}

copy(to []byte, fm string) int

copy(to []byte, fm string) int	// fm -> to
  1. copy() 函数还接收可分配给[]byte类型的目标参数，其中fm参数为字符串类型
 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func ExampleCopy() {
    var b = make([]byte, 5)

    n3 := copy(b, "Hello，World!")

    fmt.Println(n3, b)  // 5 [72 101 108 108 111]
    
    // Output:
    // 5 [72 101 108 108 111]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

func ExampleCopy()  {
    var s string = "hello Go语言"   // 8 + 2*3 = 14

    var slice1 []byte               // 创建切片 默认长度为0
    num1 := copy(slice1, s)
    fmt.Println(num1, slice1)       // 0 []

    var slice2 []byte = []byte{0}   // 创建切片 并初始化一个容量
    num2 := copy(slice2, s)
    fmt.Println(num2, slice2)       // 1 [104]

    slice3 := make([]byte, 20)      // 创建切片 初始化长度为20
    num3 := copy(slice3, s)
    fmt.Println(num3, slice3)       // 14 [104 101 108 108 111 32 71 111 232 175 173 232 168 128 0 0 0 0 0 0]

    slice4 := make([]byte, 20, 40)  // 创建切片 初始化长度为20 容量为40
    num4 := copy(slice4, s)
    fmt.Println(num4, slice4)       // 14 [104 101 108 108 111 32 71 111 232 175 173 232 168 128 0 0 0 0 0 0]

    // 由此可以看出 copy()函数 复制多少跟接受变量长度有关
    
    // Output:
    // 0 []
    // 1 [104]
    // 14 [104 101 108 108 111 32 71 111 232 175 173 232 168 128 0 0 0 0 0 0]
    // 14 [104 101 108 108 111 32 71 111 232 175 173 232 168 128 0 0 0 0 0 0]
}

1
2
3
4
5
6
7
8

func ExampleCopy() {
    slice := make([]byte, 3)
    n := copy(slice, "append")
    fmt.Println(n ,slice)   // 3 [97 112 112]
    
    // Output:
    // 3 [97 112 112]
}

copy 源码

  1. 参考本章节的原理篇。