使用Go语言时，如何检测JSON中的未定义多余字段？

方案一：直接拒绝未知字段（快速校验） #

如果你的场景需要严格校验输入，不允许出现结构体未定义的字段，可以用json.Decoder的DisallowUnknownFields()方法。启用这个选项后，反序列化遇到未知字段会直接抛出错误，无需修改原有结构体。

示例代码：

package main

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

type Foo struct {
    Bar string `json:"bar"`
}

func main() {
    jsonData := `{"bar": "demo", "baz": 2}`
    var foo Foo
    
    decoder := json.NewDecoder(strings.NewReader(jsonData))
    decoder.DisallowUnknownFields() // 开启未知字段检测
    err := decoder.Decode(&foo)
    
    if err != nil {
        fmt.Println("反序列化失败:", err)
        // 这里可以做参数错误处理，比如返回HTTP 400
        return
    }
    fmt.Println("反序列化结果:", foo)
}

执行后会输出：反序列化失败: json: unknown field "baz"

方案二：收集未知字段（自定义处理） #

如果需要保留未知字段做后续处理（比如日志记录、兼容旧数据），可以给结构体加一个隐藏的map字段，通过自定义UnmarshalJSON方法来收集这些字段。

示例代码：

package main

import (
    "encoding/json"
    "fmt"
)

type Foo struct {
    Bar          string                 `json:"bar"`
    UnknownFields map[string]interface{} `json:"-"` // 存储未知字段，序列化时会被忽略
}

// 自定义UnmarshalJSON，先解析已知字段，再收集未知字段
func (f *Foo) UnmarshalJSON(data []byte) error {
    // 临时结构体，复用Foo的已知字段定义
    type tempFoo Foo
    var temp tempFoo
    
    // 先解析已知字段
    if err := json.Unmarshal(data, &temp); err != nil {
        return err
    }
    
    // 解析所有字段到map
    var allFields map[string]interface{}
    if err := json.Unmarshal(data, &allFields); err != nil {
        return err
    }
    
    // 移除已知字段，剩下的就是未知的
    delete(allFields, "bar")
    
    // 赋值给原结构体
    *f = Foo(temp)
    f.UnknownFields = allFields
    return nil
}

func main() {
    jsonData := `{"bar": "demo", "baz": 2, "qux": "extra"}`
    var foo Foo
    
    err := json.Unmarshal([]byte(jsonData), &foo)
    if err != nil {
        fmt.Println("反序列化失败:", err)
        return
    }
    
    fmt.Println("已知字段Bar:", foo.Bar)
    fmt.Println("收集到的未知字段:", foo.UnknownFields)
}

执行后输出：

已知字段Bar: demo
收集到的未知字段: map[baz:2 qux:extra]

方案对比 #

• 方案一：代码简洁，适合严格校验场景，直接拦截非法输入
• 方案二：稍复杂，但能保留未知字段，适合需要兼容或记录额外数据的场景

内容的提问来源于stack exchange，提问作者flexagoon