Go语言数组复制方法全解析

本文介绍了在 Go 语言中复制数组和切片的几种方法，重点讲解了内置的 `copy` 函数的使用方式，以及在多维切片场景下深拷贝与浅拷贝的区别，并提供了相应的代码示例。通过本文，你将掌握在不同场景下选择合适的复制方法，避免潜在的陷阱。

在 Go 语言中，复制数组和切片是一个常见的操作。根据不同的需求，可以选择不同的方法。本文将详细介绍几种常用的复制方法，并分析它们在不同场景下的适用性。

使用 copy 函数复制切片

Go 语言提供了一个内置的 copy 函数，专门用于复制切片。其基本语法如下：

copy(dst, src []Type) int

其中，dst 是目标切片，src 是源切片，Type 是切片中元素的类型。copy 函数会将 src 切片中的元素复制到 dst 切片中，并返回实际复制的元素个数，这个数量是 dst 和 src 长度的最小值。

示例：

package main

import "fmt"

func main() {
    a := []string{
        "hello",
        "world",
    }
    b := []string{
        "goodbye",
        "world",
    }

    copy(a, b)

    fmt.Println(a) // Output: [goodbye world]
}

在这个例子中，copy(a, b) 将 b 切片的前两个元素复制到 a 切片中。因为 a 和 b 的长度都为 2，所以实际复制了 2 个元素。

注意事项：

• copy 函数会覆盖目标切片中已有的元素。
• 如果目标切片的长度小于源切片的长度，则只会复制目标切片长度个元素。
• 如果目标切片的长度大于源切片的长度，则只会复制源切片长度个元素，目标切片剩余的元素保持不变。

多维切片的浅拷贝与深拷贝

对于多维切片，copy 函数执行的是浅拷贝。这意味着，它只会复制外层切片的引用，而不会复制内层切片的引用。因此，如果修改了源切片中的内层切片，目标切片也会受到影响。

示例：

package main

import (
    "fmt"
    "strconv"
)

func main() {
    a := make([][]string, 2)

    b := make([][]string, 2)
    for i := range b {
        b[i] = make([]string, 2)
        for j := range b[i] {
            b[i][j] = strconv.Itoa(i + j)
        }
    }

    copy(a, b)

    fmt.Println("a:", a) // Output: a: [[0 1] [1 2]]
    fmt.Println("b:", b) // Output: b: [[0 1] [1 2]]

    b[0][0] = "apple"

    fmt.Println("a:", a) // Output: a: [[apple 1] [1 2]]
    fmt.Println("b:", b) // Output: b: [[apple 1] [1 2]]
}

在这个例子中，copy(a, b) 将 b 切片复制到 a 切片中。但是，当修改 b[0][0] 的值时，a[0][0] 的值也发生了改变。这是因为 a 和 b 的内层切片指向的是同一块内存地址。

如果需要对多维切片进行深拷贝，需要手动遍历切片，并复制每个内层切片。

示例：

package main

import (
    "fmt"
    "strconv"
)

func main() {
    a := make([][]string, 2)

    b := make([][]string, 2)
    for i := range b {
        b[i] = make([]string, 2)
        for j := range b[i] {
            b[i][j] = strconv.Itoa(i + j)
        }
    }

    // manual deep copy
    for i := range b {
        a[i] = make([]string, len(b[i]))
        copy(a[i], b[i])
    }

    fmt.Println("a:", a) // Output: a: [[0 1] [1 2]]
    fmt.Println("b:", b) // Output: b: [[0 1] [1 2]]

    b[0][0] = "apple"

    fmt.Println("a:", a) // Output: a: [[0 1] [1 2]]
    fmt.Println("b:", b) // Output: b: [[apple 1] [1 2]]
}

在这个例子中，我们手动遍历 b 切片，并使用 copy 函数复制每个内层切片到 a 切片中。这样，a 和 b 的内层切片指向的是不同的内存地址，修改 b[0][0] 的值不会影响 a[0][0] 的值。

使用 = 运算符复制数组

在 Go 语言中，数组是值类型。这意味着，当使用 = 运算符复制数组时，会创建一个新的数组，并将源数组中的所有元素复制到新数组中。因此，修改源数组不会影响新数组。

示例：

package main

import "fmt"

func main() {
    a := [2]string{
        "hello",
        "world",
    }
    b := a

    fmt.Println("a:", a) // Output: a: [hello world]
    fmt.Println("b:", b) // Output: b: [hello world]

    a[0] = "goodbye"

    fmt.Println("a:", a) // Output: a: [goodbye world]
    fmt.Println("b:", b) // Output: b: [hello world]
}

在这个例子中，b := a 将 a 数组复制到 b 数组中。当修改 a[0] 的值时，b[0] 的值没有发生改变。

总结：

• 对于切片，使用 copy 函数进行复制。对于多维切片，需要注意浅拷贝与深拷贝的区别，根据需求选择合适的复制方法。
• 对于数组，使用 = 运算符进行复制，会创建一个新的数组，并将源数组中的所有元素复制到新数组中。

选择合适的复制方法取决于你的具体需求。如果只需要复制切片的一部分元素，或者需要对多维切片进行深拷贝，则需要使用 copy 函数或手动遍历切片。如果需要复制整个数组，则可以使用 = 运算符。理解这些方法之间的区别，可以帮助你编写更高效、更可靠的 Go 代码。