如何判断JSON反序列化后struct字段是否未被赋值

这个问题我之前也碰到过——Go里JSON反序列化后，确实很难直接区分字段是「没被赋值」还是「被显式设成了零值」，你的当前写法刚好踩了这个坑。下面给你两个实用的解决思路，结合reflect就能搞定：

这是最直接的方案，核心是利用指针的nil状态来标记「未被JSON赋值」——JSON反序列化时，如果字段不存在，指针会保持nil；如果字段哪怕是零值（比如false、0），指针都会被分配内存并指向该值。

首先修改你的struct，把需要区分的字段改成指针类型：

type YourStruct struct {
    Username string `json:"username"`
    Age      *int   `json:"age"`
    IsActive *bool  `json:"is_active"`
}

然后结合reflect遍历判断：

var res YourStruct
err := json.Unmarshal([]byte(str), &res)
if err != nil {
    // 处理错误
}

s := reflect.ValueOf(&res).Elem()
typeOfT := s.Type()

for i := 0; i < s.NumField(); i++ {
    field := s.Field(i)
    fieldMeta := typeOfT.Field(i)

    // 检查当前字段是否为指针类型
    if field.Kind() == reflect.Ptr {
        if field.IsNil() {
            fmt.Printf("字段 %s 未被JSON赋值\n", fieldMeta.Name)
        } else {
            // 指针非nil，说明被显式赋值（哪怕是零值）
            fmt.Printf("字段 %s 的值为: %v\n", fieldMeta.Name, field.Elem().Interface())
        }
    } else {
        // 非指针类型还是会有原问题，如果必须保留值类型，建议用方案2
        fmt.Printf("字段 %s 是值类型，无法区分零值和未赋值\n", fieldMeta.Name)
    }
}

如果不能修改原有struct的字段类型（比如要保持值类型），可以通过自定义UnmarshalJSON方法，先把JSON解析成map，记录所有实际存在的字段，这样就能精准判断哪些字段是被JSON赋值过的。

举个例子：

type YourStruct struct {
    Username string `json:"username"`
    Age      int    `json:"age"`
    IsActive bool   `json:"is_active"`
    // 内部字段，用来记录JSON中实际存在的字段
    parsedFields map[string]bool
}

// 自定义UnmarshalJSON实现
func (s *YourStruct) UnmarshalJSON(data []byte) error {
    // 初始化记录字段的map
    s.parsedFields = make(map[string]bool)

    // 先把JSON解析成临时map，拿到所有存在的字段名
    var rawFields map[string]json.RawMessage
    if err := json.Unmarshal(data, &rawFields); err != nil {
        return err
    }
    for fieldName := range rawFields {
        s.parsedFields[fieldName] = true
    }

    // 再反序列化到临时结构体，避免递归调用
    type temp YourStruct
    var t temp
    if err := json.Unmarshal(data, &t); err != nil {
        return err
    }

    // 把临时结构体的值赋值给原结构体
    *s = YourStruct(t)
    return nil
}

然后用reflect遍历判断：

var res YourStruct
err := json.Unmarshal([]byte(str), &res)
if err != nil {
    // 处理错误
}

s := reflect.ValueOf(&res).Elem()
typeOfT := s.Type()

for i := 0; i < s.NumField(); i++ {
    fieldMeta := typeOfT.Field(i)
    // 跳过内部的parsedFields字段
    if fieldMeta.Name == "parsedFields" {
        continue
    }

    // 获取字段的json标签，没有标签就用字段名
    jsonTag := fieldMeta.Tag.Get("json")
    if jsonTag == "" {
        jsonTag = fieldMeta.Name
    }

    if !res.parsedFields[jsonTag] {
        fmt.Printf("字段 %s 未被JSON赋值\n", fieldMeta.Name)
    } else {
        fmt.Printf("字段 %s 被赋值为: %v\n", fieldMeta.Name, s.Field(i).Interface())
    }
}

这个方案的好处是不用修改原有字段的类型，完全通过反序列化过程来跟踪字段是否被赋值，哪怕是零值也能准确区分。

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