在日常的Go开发中，我们经常需要操作切片（slice）。有时我们需要将一个切片的内容复制到另一个切片中，这时候Go语言内置的copy()函数就派上了用场。

什么是copy函数？

copy()函数是Go语言的一个内置函数，它的作用是将一个切片中的元素复制到另一个切片中。它的函数签名非常简单：

func copy(dst, src []Type) int

其中，dst是目标切片，src是源切片，Type是切片元素的类型。函数返回一个整数值，表示实际复制的元素个数。

copy函数的基本用法

让我们来看一个最简单的例子：

package main

import "fmt"

func main() {
    // 源切片
    sourceSlice := []int{1, 2, 3, 4, 5}
    // 目标切片
    destinationSlice := make([]int, len(sourceSlice))

    // 使用copy函数复制源切片到目标切片
    numCopied := copy(destinationSlice, sourceSlice)

    // 打印结果
    fmt.Println("Source slice:", sourceSlice)
    fmt.Println("Destination slice:", destinationSlice)
    fmt.Println("Number of elements copied:", numCopied)
}

输出结果：

Source slice: [1 2 3 4 5]
Destination slice: [1 2 3 4 5]
Number of elements copied: 5

在这个例子中，我们创建了一个名为sourceSlice的切片，然后使用make函数创建了一个和sourceSlice相同长度的目标切片destinationSlice。接着，我们使用copy()函数将sourceSlice中的元素复制到destinationSlice，并打印了两个切片的内容和复制的元素个数。

copy函数的特点

1. 复制长度取最小值

copy()函数只会复制len(src)和len(dst)中的较小值个元素。这意味着如果目标切片的长度小于源切片，只会复制部分元素：

func main() {
    sourceSlice := []int{1, 2, 3, 4, 5}
    destinationSlice := make([]int, 3) // 只分配3个元素的空间

    numCopied := copy(destinationSlice, sourceSlice)

    fmt.Println("Copied elements:", numCopied) // Output: 3
    fmt.Println("Destination slice:", destinationSlice) // Output: [1 2 3]
}

2. 类型必须匹配

copy()函数要求目标切片和源切片的元素类型必须一致。如果类型不一致，编译器会报错：

src := []int{1, 2, 3}
dst := make([]float64, len(src))
n := copy(dst, src) // 编译错误：类型不匹配

3. 不会自动扩容

copy()函数只会复制目标切片长度范围内的元素，不会自动扩展目标切片的容量。如果需要复制更多的元素，需要确保目标切片的长度足够。

4. 不会修改源切片

重要的是，copy()函数只是将源切片中的元素复制到目标切片中，不会修改源切片的内容。修改目标切片不会影响源切片。

深浅复制的问题

在使用copy()函数时，我们需要特别注意深浅复制的问题。

浅复制（Shallow Copy）

copy()函数实现的是浅复制。对于基本数据类型（如int、string、float等），复制后两个切片是独立的；但如果切片元素是引用类型（如指针、切片、map等），复制的是引用而不是值。

func main() {
    matA := [][]int{
        {0, 1, 1, 0},
        {0, 1, 1, 1},
        {1, 1, 1, 0},
    }
    matB := make([][]int, len(matA))
    copy(matB, matA)

    // matA和matB的地址不同，但matA[0]和matB[0]的地址相同！
    fmt.Printf("%p, %p\n", matA, matA[0]) // 0x14000130000, 0x1400012e020
    fmt.Printf("%p, %p\n", matB, matB[0]) // 0xc00012a0500, 0x1400012e020
}

深复制（Deep Copy）

如果需要完全断开两个切片之间的关联，就需要实现深复制。对于多维切片，需要手动进行深复制：

func main() {
    matA := [][]int{
        {0, 1, 1, 0},
        {0, 1, 1, 1},
        {1, 1, 1, 0},
    }
    matB := make([][]int, len(matA))

    for i := range matA {
        matB[i] = make([]int, len(matA[i])) // 注意初始化长度
        copy(matB[i], matA[i])
    }

    // 现在matA和matB的地址以及内部切片的地址都不同了
    fmt.Printf("%p, %p\n", matA, matA[0]) // 0x1400013c000, 0x1400013a020
    fmt.Printf("%p, %p\n", matB, matB[0]) // 0x1400013c050, 0x1400013a080
}

copy函数的常见用途

1. 切片扩容

Go语言中切片扩容时，常用copy()来复制老数据：

func main() {
    oldSlice := []int{1, 2, 3}
    newSlice := make([]int, len(oldSlice)*2) // 双倍扩容
    copy(newSlice, oldSlice)
    fmt.Println("New slice:", newSlice) // [1 2 3 0 0 0]
}

2. 截取切片部分内容

可以使用copy()函数来截取切片的一部分：

func main() {
    src := []int{1, 2, 3, 4, 5}
    dst := make([]int, 3)
    copy(dst, src[1:4]) // 复制src中索引1到4的元素（不包含索引4）
    fmt.Println("Destination slice:", dst) // [2 3 4]
}

3. 避免切片共享底层数组

在Go语言中，切片是引用类型，多个切片可能会共享同一个底层数组。可以使用copy()函数创建一个新的切片：

func main() {
    src := []int{1, 2, 3, 4, 5}
    dst := make([]int, len(src))
    copy(dst, src)
    dst[0] = 100 // 修改dst不会影响src
    fmt.Println("Source:", src) // [1 2 3 4 5]
    fmt.Println("Destination:", dst) // [100 2 3 4 5]
}

4. 复制字符串到字节切片

copy()函数还可以用于将字符串复制到字节切片中：

func main() {
    src := "Hello, World!"
    dst := make([]byte, len(src))
    n := copy(dst, src)
    fmt.Println("Copied elements:", n) // 13
    fmt.Println("Destination slice:", dst) 
    // [72 101 108 108 111 44 32 87 111 114 108 100 33]
}

性能优化

值得一提的是，copy()函数是Go语言运行时高度优化的内置函数。在大多数情况下，它会利用底层的内存复制指令（如memcpy），因此在处理大量数据时效率极高，远超手动编写的循环复制。

总结

copy()函数是Go语言中一个非常实用的内置函数，用于将数据从一个切片复制到另一个切片。它的使用非常简单，但需要注意目标切片和源切片的类型必须一致，并且目标切片的长度决定了复制的元素个数。

通过copy()函数，我们可以高效地复制切片、截取切片的一部分、避免切片共享底层数组等。