Go json.Decoder.More 为什么只能在数组或对象中判断后续元素

我第一次把 json.Decoder.More() 放进通用 JSON 读取循环时，误以为它是在回答“输入流里还有没有下一个 JSON 值”。实际不是这样：More 只判断当前已经进入的数组或对象是否还有成员。数组里它对应下一个元素，对象里它对应下一组键值对；顶层连续 JSON 值、普通字段值和结束分隔符，都应该交给 Token、Decode 或错误处理来判断。

官方地址：https://pkg.go.dev/encoding/json#Decoder.More

More 判断的是当前容器，不是整个输入流

JSON 的数组和对象都有明确的开始、成员区和结束分隔符。Decoder.More 的语义依赖这个容器上下文：调用前，解码器应该已经消费了数组的 [ 或对象的 {。它回答的是“当前这对分隔符里还有没有下一个成员”，因此空数组和空对象会让循环一次都不进入。

如果输入是连续的顶层值，例如 1 true {"ok":true}，More 没有“顶层还有值吗”的职责。此时应连续调用 Decode，让每次返回的错误决定是否到达输入末尾；如果输入格式要求单个 JSON 值，则还要明确拒绝额外内容。

数组里先读左括号，再用 More 解码元素

数组是最直观的使用场景。先用 Token 消费左方括号，然后循环调用 More；每次循环体只负责读取一个完整元素，最后再消费右方括号。这样写的好处是，逗号和数组结束符由解码器按 JSON 语法处理，业务代码只关心元素类型。

package main

import (
	"encoding/json"
	"fmt"
	"strings"
)

type Item struct {
	ID int `json:"id"`
}

func readItems(input string) ([]Item, error) {
	dec := json.NewDecoder(strings.NewReader(input))
	start, err := dec.Token() // 先消费数组的左方括号，建立 More 的上下文
	if err != nil {
		return nil, err // 输入不是完整 JSON 时保留解析错误
	}
	if delim, ok := start.(json.Delim); !ok || delim != '[' {
		return nil, fmt.Errorf("期望数组，实际是 %v", start) // 不让对象误走数组循环
	}

	var items []Item
	for dec.More() { // 只判断当前数组是否还有下一个元素
		var item Item
		if err := dec.Decode(&item); err != nil { // 元素错误不能被 More 掩盖
			return nil, err
		}
		items = append(items, item)
	}

	end, err := dec.Token() // 循环结束后消费数组的右方括号
	if err != nil {
		return nil, err
	}
	if delim, ok := end.(json.Delim); !ok || delim != ']' {
		return nil, fmt.Errorf("数组没有正常结束，实际是 %v", end)
	}
	return items, nil
}

这里的 More 不负责判断 Item 是否有效，也不负责把值解码成结构体。它只负责控制当前数组的成员边界；真正的类型错误、截断输入和非法 JSON，仍由 Token 或 Decode 返回。

对象里一次 More 对应一组键和值

对象循环比数组多一步：每次成员由一个 key 和一个 value 组成。进入对象后，More 判断是否还有下一组键值对；循环体先读取字符串 key，再调用 Decode 读取它对应的 value，最后消费 }。

func readObject(input string) (map[string]any, error) {
	dec := json.NewDecoder(strings.NewReader(input))
	tok, err := dec.Token() // 先消费对象的左花括号
	if err != nil {
		return nil, err
	}
	if delim, ok := tok.(json.Delim); !ok || delim != '{' {
		return nil, fmt.Errorf("期望对象，实际是 %v", tok)
	}

	result := make(map[string]any)
	for dec.More() { // 当前对象还有下一组 key/value 时继续
		keyToken, err := dec.Token() // 对象成员的 key 是下一个字符串 token
		if err != nil {
			return nil, err
		}
		key, ok := keyToken.(string)
		if !ok {
			return nil, fmt.Errorf("对象键不是字符串：%v", keyToken)
		}
		var value any
		if err := dec.Decode(&value); err != nil { // value 可以是标量、数组或对象
			return nil, err
		}
		result[key] = value
	}

	end, err := dec.Token() // 对象循环结束后必须消费右花括号
	if err != nil {
		return nil, err
	}
	if delim, ok := end.(json.Delim); !ok || delim != '}' {
		return nil, fmt.Errorf("对象没有正常结束，实际是 %v", end)
	}
	return result, nil
}

对象中的 More 并不会替你读取 key，也不会跳过 value。若循环中少调用一次 Decode，下一个 Token 就可能读到仍属于当前成员的值，随后出现“对象结束符不匹配”这类看似无关的错误。

嵌套结构和顶层多值要分开处理

遇到嵌套数组时，外层循环中的 Decode 可以把整个内层数组解码给目标类型，也可以再次读取分隔符并进入新的 More 上下文。关键是：每一层容器都拥有自己的成员边界，不能把外层的 More 当成内层状态。

排查“循环没有进入”时，我会按下面顺序看：

1. 是否已经用 Token 读到了正确的 [ 或 {；空容器本来就不会进入循环。
2. 数组循环是否每次只解码一个元素，对象循环是否成对读取 key 和 value。
3. 循环结束后是否消费了对应的 ] 或 }，避免把结束符留给外层逻辑。
4. 是否把 More 错当成顶层 EOF 判断；顶层连续值应该用 Decode 的错误和业务规则判断。
5. 错误发生时是否保留了原始错误，而不是只返回“没有更多数据”这样的模糊信息。

常见问题

为什么空数组里 More 返回 false？

因为当前数组没有成员，false 是正常结果。随后仍应读取并检查数组的右方括号，而不是把 false 当成整个 JSON 输入无效。

可以用 More 判断顶层还有没有第二个 JSON 吗？

不建议。More 依赖数组或对象上下文；顶层多值应按协议连续调用 Decode，再根据是否允许额外值处理 EOF 或业务错误。