Go 问答：nil slice 和空 slice 有什么区别，JSON 为什么一个是 null 一个是 []

Go 里有一个很常见但容易忽略的问题：nil slice 和空 slice 都可以 len == 0，循环也都不会报错，但它们在 JSON 输出时可能完全不同。一个会变成 null，一个会变成 []。

这个差异在接口开发里很实际。前端期望拿到数组，结果有时是 null，就可能多写一堆空值判断。我们这篇按问答排查的方式来走：先复现现象，再看 slice 结构，最后给出稳定返回 [] 的写法。

摘要

nil slice 的指针为 nil，没有指向底层数组；空 slice 的长度也是 0，但通常已经有一个非 nil 的 slice 头。二者在 len、cap 上可能看起来一样，但 json.Marshal 会把 nil slice 编码为 null，把空 slice 编码为 []。接口响应建议在返回前初始化空切片。

适合人群

• 刚开始写 Go API 响应结构体，遇到数组字段返回 null 的读者。
• 已经知道 slice 基本用法，但想分清 nil 和空切片区别的开发者。
• 需要让 Go 后端接口响应更稳定、更易被前端处理的同学。

问题现场：为什么接口有时返回 null

先看一个接口响应结构体：

type UserListResp struct {
    Items []string `json:"items"`
}

业务逻辑没有查到用户时，我们直接返回一个零值结构体：

resp := UserListResp{}
data, _ := json.Marshal(resp)
fmt.Println(string(data))

输出结果是：

{"items":null}

但很多接口希望空列表返回 []，也就是：

{"items":[]}

现在问题来了：明明没有数据，为什么一个是 null，一个是空数组？

先复现：两个 slice 的 len 都是 0

我们先写最小代码，把 nil slice 和空 slice 放在一起看。

var a []string
b := []string{}

fmt.Println(len(a), cap(a), a == nil)
fmt.Println(len(b), cap(b), b == nil)

常见输出是：

0 0 true
0 0 false

这一步说明：只看 len 和 cap 不够。两个 slice 长度都为 0，但是否为 nil 不一样。

继续验证：nil 判断结果不同

继续加一个判断就更清楚了：

func printState(name string, s []string) {
    if s == nil {
        fmt.Println(name, "is nil")
        return
    }
    fmt.Println(name, "is not nil, len =", len(s))
}

printState("a", a)
printState("b", b)

a 是 nil slice，表示它没有指向任何底层数组；b 是空 slice，表示它是一个有效切片，只是长度为 0。

定位原因：底层数组和指针状态不同

slice 本身可以理解成一个小结构，里面包含指向底层数组的指针、长度和容量。nil slice 的指针为 nil；空 slice 的长度为 0，但它通常已经是一个非 nil 的切片值。

这也是为什么下面两个写法含义不同：

var items []string      // nil slice
items2 := []string{}    // 空 slice

在普通循环里，它们都可以安全遍历：

for _, item := range items {
    fmt.Println(item)
}

没有元素，所以不会进入循环。真正让差异暴露出来的，通常是 JSON 编码、数据库保存或跨服务响应。

JSON 输出：null 和 [] 的根源

现在直接验证 JSON 行为。

type Resp struct {
    Items []string `json:"items"`
}

resp1 := Resp{}
resp2 := Resp{Items: []string{}}

data1, _ := json.Marshal(resp1)
data2, _ := json.Marshal(resp2)

fmt.Println(string(data1))
fmt.Println(string(data2))

输出结果：

{"items":null}
{"items":[]}

到这里就能定位原因：不是 JSON 包随机输出，而是原始 slice 状态不同。nil slice 对应 null，空 slice 对应空数组。

修复方案：接口返回前主动初始化

如果你的接口约定数组字段始终返回数组，那么返回前要做初始化。

func buildResp(items []string) Resp {
    if items == nil {
        items = []string{}
    }
    return Resp{Items: items}
}

如果字段比较多，可以在构造响应时统一处理，而不是在每个调用点散落判断。

func emptyUserListResp() Resp {
    return Resp{
        Items: []string{},
    }
}

接口返回稳定后，前端就可以统一按数组处理，减少 null 分支。

常见误区

误区一：len 为 0 就完全等价

不等价。长度一样，只能说明当前元素数量一样，不能说明底层状态和 JSON 输出一样。

误区二：所有地方都必须把 nil slice 转成空 slice

不需要。内部逻辑里 nil slice 很常见，也很自然。真正需要统一的是对外协议，例如 API 响应字段。

误区三：用 omitempty 就能得到 []

omitempty 会让空值字段被省略，不是输出 []。如果接口要求字段存在且为数组，就不要依赖它。

总结

这道 Go 问答的关键点是：nil slice 和空 slice 都可以长度为 0，但语义不同。nil slice 表示没有指向底层数组；空 slice 表示有一个长度为 0 的切片值。

在 Go 内部逻辑中，二者很多时候都能正常使用；但在 JSON 输出和接口协议里，差异会变得明显。建议对外 API 明确约定：如果字段表示列表，返回前主动初始化为空 slice，让响应始终保持 []。