Go encoding/json.Decoder.Token 怎么遍历未知 JSON：Token、More 与嵌套对象边界

配置中心把 JSON 从固定结构改成了“字段可能随版本增加”的对象后，直接反序列化到结构体不再适合做第一层检查。Go 的 encoding/json.Decoder.Token 会按顺序交出字段名、值和 json.Delim，配合 More 可以先走完嵌套边界，再决定哪些字段交给业务代码。

记住一个边界：Token 负责拿到下一个 JSON token，More 只回答当前数组或对象里是否还有元素；它不是“输入流是否结束”的判断。

Token 到底交出了哪些结构信息

json.Decoder 的输入不是一次性字节数组，而是一条 token 流。对象开始、对象结束、数组开始、数组结束会以 json.Delim 出现；字段名和字符串都是 Go 的 string，数字默认是 float64，JSON 的 null 会得到 nil。

下面的循环适合先观察一段未知 JSON 的真实结构：

dec := json.NewDecoder(strings.NewReader(`{"profile":{"name":"Lin","roles":["admin","reviewer"]}}`))
for {
    tok, err := dec.Token()
    if errors.Is(err, io.EOF) {
        break
    }
    if err != nil {
        return err
    }
    fmt.Printf("%T: %v\n", tok, tok)
}

这里的 io.EOF 只说明 token 流已经读完。若 JSON 在字符串或数字中间被截断，解析器会返回语法错误或意外结束错误，不能把所有非 nil 错误都当成正常结束。

More 的判断范围是当前容器

调用 More 前，程序必须已经进入一个数组或对象。它观察的是当前容器的下一个位置，不会替你消费 token，也不会替你处理嵌套对象。解析数组时，典型顺序是读取 [、循环判断 More、读取元素、最后读取 ]。

dec := json.NewDecoder(strings.NewReader(`{"roles":["admin","reviewer"]}`))
start, err := dec.Token()
if err != nil || start != json.Delim('{') {
    return fmt.Errorf("want object start: %v", err)
}

key, err := dec.Token()
if err != nil || key != "roles" {
    return fmt.Errorf("want roles: %v", err)
}
arrayStart, err := dec.Token()
if err != nil || arrayStart != json.Delim('[') {
    return fmt.Errorf("want array start: %v", err)
}
for dec.More() {
    tok, err := dec.Token()
    if err != nil {
        return err
    }
    fmt.Println(tok)
}
end, err := dec.Token()
if err != nil || end != json.Delim(']') {
    return fmt.Errorf("want array end: %v", err)
}

More 在这里不会跨出 roles 数组去判断外层对象。读到 ] 后，如果还要继续处理对象中的其他字段，下一次应回到外层对象的 More 循环，而不是继续沿用数组的判断。

未知字段要跳过完整值，而不是丢一个 Token

只读对象的字段名时，值可能是字符串，也可能是包含数组和对象的复合结构。对未知字段直接调用一次 Token 只能跳过值的第一个 token；如果值是对象，剩余的嵌套 token 还会污染外层循环。

func skipValue(dec *json.Decoder) error {
    tok, err := dec.Token()
    if err != nil {
        return err
    }
    delim, ok := tok.(json.Delim)
    if !ok || (delim != '{' && delim != '[') {
        return nil
    }

    close := json.Delim('}')
    if delim == '[' {
        close = ']'
    }
    for dec.More() {
        if err := skipValue(dec); err != nil {
            return err
        }
    }
    end, err := dec.Token()
    if err != nil {
        return err
    }
    if end != close {
        return fmt.Errorf("unexpected delimiter %v", end)
    }
    return nil
}

真实业务通常还要在对象循环中先读取字段名，再根据字段名决定调用 Decode 到目标变量，还是调用 skipValue。递归的停止点就是匹配到对应的 json.Delim，因此嵌套数组不会把外层游标推乱。

从旧写法迁移时先核对三个边界

如果旧代码用 map[string]any 先完整解码，再遍历字段，改成 token 流读取后会少一次完整对象的中间表示，但也承担了结构边界责任。迁移时至少检查三件事：是否严格区分对象和数组的结束符、是否为每个复合未知值完整跳过、是否把顶层 io.EOF 与截断错误区分开。

数字也要单独核对。Token 默认把 JSON 数字交给 float64；如果需要保留大整数的文本精度，可以在读取 token 前调用 dec.UseNumber()，然后按字段语义把 json.Number 转成整数或小数。

常见问题：Token 和 More 怎么选

More 可以直接判断整个 JSON 是否还有内容吗？

不可以。它只适用于当前数组或对象内部；顶层连续 JSON 值应循环调用 Token，并把 io.EOF 当作正常结束。

读取对象字段名后能直接调用 Decode 吗？

可以。字段名已经由 Token 消费后，Decode 会从对应字段值开始读取；未知的复合值则要完整跳过或解码到临时变量。

Token 能替代所有 JSON 反序列化吗？

不能。固定结构仍适合直接 Decode 到结构体；Token 更适合结构未知、需要保留流式读取或先做结构路由的场景。

把结束符当作解析结果的一部分

Token 和 More 配合时，真正重要的不是记住几段模板代码，而是维护当前容器的边界：进入 { 或 [ 后由 More 遍历，读到匹配的结束符后返回上一层，顶层再用 io.EOF 收口。这样处理未知字段时，业务逻辑可以变化，解析游标却不会失控。