在Golang开发中，数组作为基础数据结构，其拷贝与赋值操作的性能直接影响程序运行效率。不同的实现方式在内存占用和执行速度上存在明显差异，需要根据具体场景选择合适的方法。
Golang数组的基本特性
Golang中的数组是值类型，长度固定，声明时需要指定元素类型和数组长度。当数组作为函数参数传递或者进行直接赋值时，会触发整个数组的拷贝，这一点和切片这种引用类型有明显区别。比如声明一个长度为5的int类型数组：
package main
import "fmt"
func main() {
// 声明长度为5的int数组
var arr [5]int
arr[0] = 1
arr[1] = 2
fmt.Println(arr) // 输出 [1 2 0 0 0]
}
常见数组拷贝与赋值方式及性能对比
1. 直接赋值
直接赋值是最简单的数组拷贝方式，利用Golang数组的值类型特性，将一个数组变量直接赋值给另一个同类型同长度的数组变量，会触发完整的数组内容拷贝。
package main
import "fmt"
func main() {
var src [1000]int
// 初始化源数组
for i := 0; i < len(src); i++ {
src[i] = i
}
// 直接赋值拷贝数组
var dst [1000]int
dst = src
fmt.Println(dst[0], dst[999]) // 输出 0 999
}
这种方式在编译期就能确定拷贝的大小，生成的机器码效率很高，对于长度不大的数组来说，是最优的选择，不需要额外的函数调用开销。
2. 使用内置copy函数
内置的copy函数通常用于切片的拷贝，但也可以先将数组转换为切片，再使用copy完成拷贝。不过这种方式需要先获取数组的切片引用，会多一步操作。
package main
import "fmt"
func main() {
var src [1000]int
for i := 0; i < len(src); i++ {
src[i] = i
}
var dst [1000]int
// 将数组转成切片后使用copy拷贝
copy(dst[:], src[:])
fmt.Println(dst[0], dst[999]) // 输出 0 999
}
这种方式和直接赋值的性能差异很小，但在数组长度特别大的场景下，直接赋值的效率会略高，因为copy函数需要处理切片的长度判断逻辑。
3. 手动循环赋值
通过for循环逐个元素赋值的方式也可以实现数组拷贝，这种方式可以灵活控制拷贝的范围，但性能通常不如前两种方式。
package main
import "fmt"
func main() {
var src [1000]int
for i := 0; i < len(src); i++ {
src[i] = i
}
var dst [1000]int
// 手动循环拷贝元素
for i := 0; i < len(src); i++ {
dst[i] = src[i]
}
fmt.Println(dst[0], dst[999]) // 输出 0 999
}
手动循环会引入循环判断和索引访问的开销，在数组长度较大时，性能会比直接赋值低10%左右，除非有特殊的拷贝逻辑（比如只拷贝部分元素），否则不推荐这种方式。
性能测试对比
我们可以编写基准测试来对比三种方式的性能差异，测试代码如下：
package main
import "testing"
// 数组长度定义为常量，方便统一修改
const arrSize = 1000
// 直接赋值拷贝基准测试
func BenchmarkArrayDirectAssign(b *testing.B) {
var src [arrSize]int
for i := 0; i < arrSize; i++ {
src[i] = i
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
var dst [arrSize]int
dst = src
_ = dst
}
}
// copy函数拷贝基准测试
func BenchmarkArrayCopyFunc(b *testing.B) {
var src [arrSize]int
for i := 0; i < arrSize; i++ {
src[i] = i
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
var dst [arrSize]int
copy(dst[:], src[:])
_ = dst
}
}
// 手动循环拷贝基准测试
func BenchmarkArrayLoopAssign(b *testing.B) {
var src [arrSize]int
for i := 0; i < arrSize; i++ {
src[i] = i
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
var dst [arrSize]int
for j := 0; j < arrSize; j++ {
dst[j] = src[j]
}
_ = dst
}
}
执行基准测试后，通常会得到类似的结果：直接赋值的耗时最短，copy函数方式次之，手动循环耗时最长。具体数值会根据数组长度和运行环境略有差异，但整体趋势一致。
优化建议
- 对于同类型同长度的数组拷贝，优先使用直接赋值的方式，性能最优且代码最简洁。
- 如果只需要拷贝数组的部分元素，或者拷贝逻辑有特殊要求，可以选择手动循环的方式，避免不必要的全量拷贝。
- 尽量不要将数组转成切片后再用
copy拷贝，除非同时需要操作切片，否则直接赋值的效率更高。 - 如果数组长度非常大，且不需要修改原数组的内容，可以考虑传递数组的指针，避免拷贝整个数组带来的性能损耗。
注意事项
需要注意数组和切片的区别，数组是值类型，赋值时一定会拷贝全部内容；切片是引用类型，赋值只是拷贝切片的头部信息，不会拷贝底层数组。如果实际场景中需要频繁操作动态长度的元素集合，优先考虑使用切片，而不是固定长度的数组，避免不必要的数组拷贝操作。
另外，在函数中传递数组时，如果数组长度较大，建议传递数组指针，减少栈上的内存拷贝开销，比如函数签名可以定义为func process(arr *[1000]int)，而不是func process(arr [1000]int)。