Go slices.Clone 和 copy 在 nil 切片上有什么区别

把一个 Go 切片复制给另一个变量时，真正容易出错的不是元素有没有复制，而是“没有元素”到底代表什么。nil 切片、长度为 0 但非 nil 的切片，在接口返回、JSON 编码或状态判断里可能承担不同含义。

结论先说：slices.Clone(src) 会做浅复制，并保留 src 的 nil 性；src == nil 时结果仍为 nil。内置 copy(dst, src) 只复制元素，不负责创建目标切片，结果是否为 nil 取决于你传入的 dst。如果接口契约要求保留 nil 语义，优先用 slices.Clone；必须用 copy 时，要先显式处理 nil。

先区分 nil 切片与长度为零的非 nil 切片

排查这类问题时，先不要只打印切片内容。fmt.Println 会把 nil 切片和空切片都显示成 []，看起来像同一个状态。用 %#v 加上 src == nil，才能同时看到底层写法和 nil 性。

package main

import "fmt"

func main() {
	var nilSlice []int
	emptySlice := []int{}
	values := []int{10, 20}

	// %#v 显示切片的具体形态，nil 判断显示接口语义。
	for name, src := range map[string][]int{
		"nilSlice":   nilSlice,
		"emptySlice": emptySlice,
		"values":     values,
	} {
		fmt.Printf("%s: %#v nil=%v len=%d cap=%d\n",
			name, src, src == nil, len(src), cap(src))
	}
}

这个检查把三个状态分开了：nilSlice 的值是 nil；emptySlice 的长度也是 0，但它本身不是 nil；values 同时有元素和底层存储。后面比较复制函数时，最重要的观察项就是 nil，不是打印出来的方括号。

slices.Clone 为什么能保留 nil 语义

slices.Clone 的用途就是返回一个切片副本。它逐个赋值复制元素，因此对基本类型来说修改副本不会改动原切片；但官方文档也明确说明，这只是浅复制，元素内部若含指针、切片或 map，内部对象仍可能共享。

它还有一个容易被忽略的保证：结果保留输入切片的 nil 性。下面的三组调用分别覆盖 nil、非 nil 空切片和普通切片。

package main

import (
	"fmt"
	"slices"
)

func main() {
	var nilSlice []int
	emptySlice := []int{}
	values := []int{10, 20}

	// Clone 负责创建副本，并保留输入的 nil / 非 nil 状态。
	clonedNil := slices.Clone(nilSlice)
	clonedEmpty := slices.Clone(emptySlice)
	clonedValues := slices.Clone(values)
	clonedValues[0] = 99 // 基本元素已与原切片分离。

	fmt.Printf("nil: %v, empty: %v, values: %v, original: %v\n",
		clonedNil == nil, clonedEmpty == nil, clonedValues, values)
}

在这里，clonedNil == nil 为 true，clonedEmpty == nil 为 false；而修改 clonedValues[0] 不会改变 values[0]。所以，当返回值要表达“没有提供数据”和“明确提供了一个空集合”两种状态时，slices.Clone 更贴合这个契约。

copy 只负责搬运元素，目标切片决定结果

copy 的签名是 copy(dst, src) int。它返回实际复制的元素数量，最多是两个切片长度中的较小值；它不会因为源切片有数据，就自动帮你创建目标切片。

package main

import "fmt"

func main() {
	src := []int{10, 20, 30}
	var nilDst []int
	emptyDst := make([]int, len(src))
	shortDst := make([]int, 1)

	// nilDst 没有可写元素，copy 不会替它分配空间。
	nilCount := copy(nilDst, src)
	// make 先决定目标长度，copy 再填入对应位置。
	emptyCount := copy(emptyDst, src)
	shortCount := copy(shortDst, src)

	fmt.Printf("nil: n=%d nil=%v\n", nilCount, nilDst == nil)
	fmt.Printf("make: n=%d value=%v nil=%v\n", emptyCount, emptyDst, emptyDst == nil)
	fmt.Printf("short: n=%d value=%v\n", shortCount, shortDst)
}

这个例子里，传入 nil 目标时返回数量为 0，目标仍是 nil；用 make 创建的目标是非 nil，复制数量可以达到源切片长度；长度不足的目标只接收它容得下的元素。换句话说，copy 是“把已有空间填上”，不是“创建一个和源切片等价的副本”。

按接口契约选择复制方式并检查浅复制边界

如果目标只是得到一个独立的基本类型切片，下面的选择足够实用：

兼容写法可以这样封装。关键不是把两行 API 换成三行，而是让 nil 语义成为显式分支，避免后续维护者误以为 make([]T, 0) 与 nil 等价。

func cloneKeepNil(src []int) []int {
	if src == nil {
		// nil 输入返回 nil，保持调用方可观察的语义。
		return nil
	}

	dst := make([]int, len(src))
	// 目标已经按源长度分配，copy 只负责搬运元素。
	copy(dst, src)
	return dst
}

最后再检查一次“浅复制”边界：[]map[string]int 或 [][]int 复制后，外层切片的槽位独立，但槽位里引用的 map 或内层切片仍可能共享。若业务要求完全隔离，还需要逐元素创建内部对象，不能只把 Clone 换成 copy。

常见问题

nil 切片和空切片在 len 上有区别吗？

没有，二者的 len 都是 0；区别在于 src == nil、接口编码和业务契约。

copy(nil, src) 会自动分配目标空间吗？

不会。它返回 0，目标仍为 nil。需要空间时应先用 make 创建目标，或直接使用 slices.Clone。

slices.Clone 是深复制吗？

不是。它复制切片元素本身；元素里保存的指针、map 或内层切片仍可能指向同一对象。

只想复制元素，不关心 nil 状态，怎么选？

写入已有缓冲区时选 copy；要得到一份独立切片时选 slices.Clone，代码意图会更直观。

这类问题的排查顺序可以固定下来：先看 src == nil，再看目标是否已分配，最后确认元素内部是否还存在共享引用。这样就不会把“长度为 0”“没有分配空间”和“复制结果为 nil”混成一件事。