如何检查JSON匹配结构体字段？验证json.Unmarshal是否映射全部字段？

你提到的用指针字段来判断是否被赋值的思路确实可行，但确实有点繁琐——尤其是结构体字段多的时候，写起来太麻烦了。这里给你几个更简便的方案，看看哪个适合你的场景：

方案一：自定义UnmarshalJSON方法追踪字段赋值 #

你可以给目标结构体实现json.Unmarshaler接口，在解析过程中自动记录哪些字段被JSON数据实际赋值了，完全不用把所有字段改成指针：

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
)

type User struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
	City string `json:"city"`
}

// 定义一个带追踪能力的嵌入结构体，用来辅助解析
type trackedUser struct {
	User
	setFields map[string]bool
}

func (u *User) UnmarshalJSON(data []byte) error {
	tracked := trackedUser{
		setFields: make(map[string]bool),
	}
	// 先把JSON解析到原结构体里
	if err := json.Unmarshal(data, &tracked.User); err != nil {
		return err
	}

	// 再把JSON解析成map，拿到所有实际存在的字段键
	var rawMap map[string]interface{}
	if err := json.Unmarshal(data, &rawMap); err != nil {
		return err
	}

	// 遍历原结构体的字段，对比map里的键，标记哪些字段被设置了
	val := reflect.ValueOf(&tracked.User).Elem()
	typ := val.Type()
	for i := 0; i < typ.NumField(); i++ {
		field := typ.Field(i)
		jsonTag := field.Tag.Get("json")
		if jsonTag == "" {
			jsonTag = field.Name // 没有json标签就用字段本身的名字
		}
		if _, exists := rawMap[jsonTag]; exists {
			tracked.setFields[jsonTag] = true
		}
	}

	// 检查是否有字段没被设置
	for i := 0; i < typ.NumField(); i++ {
		field := typ.Field(i)
		jsonTag := field.Tag.Get("json")
		if jsonTag == "" {
			jsonTag = field.Name
		}
		if !tracked.setFields[jsonTag] {
			return errors.New(fmt.Sprintf("缺少必填字段: %s", jsonTag))
		}
	}

	// 把解析好的值赋值给原结构体
	*u = tracked.User
	return nil
}

func main() {
	// 测试：缺少city字段的JSON
	jsonData := []byte(`{"name":"Alice","age":30}`)
	var user User
	err := json.Unmarshal(jsonData, &user)
	if err != nil {
		fmt.Println("解析错误:", err) // 输出: 解析错误: 缺少必填字段: city
	} else {
		fmt.Println("用户信息:", user)
	}

	// 测试：字段完整的JSON
	jsonDataFull := []byte(`{"name":"Bob","age":25,"city":"New York"}`)
	var userFull User
	err = json.Unmarshal(jsonDataFull, &userFull)
	if err != nil {
		fmt.Println("解析错误:", err)
	} else {
		fmt.Println("用户信息:", userFull) // 输出: 用户信息: {Bob 25 New York}
	}
}

这个方法的好处是完全不用修改原结构体的字段类型，解析时就能直接校验，不符合要求的话直接抛出错误。

方案二：先解析为Map，事后对比结构体字段 #

如果不需要在解析时立刻校验，而是想在解析完成后再检查，那可以先把JSON解析成map[string]interface{}，然后遍历结构体的所有字段（注意解析json标签），对比Map里的键是否齐全：

package main

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

type User struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
	City string `json:"city"`
}

func checkAllFieldsMapped(jsonData []byte, s interface{}) (bool, []string) {
	var rawMap map[string]interface{}
	if err := json.Unmarshal(jsonData, &rawMap); err != nil {
		return false, []string{err.Error()}
	}

	val := reflect.ValueOf(s).Elem()
	typ := val.Type()
	missingFields := []string{}

	// 遍历结构体字段，检查是否在Map中存在
	for i := 0; i < typ.NumField(); i++ {
		field := typ.Field(i)
		jsonTag := field.Tag.Get("json")
		if jsonTag == "" {
			jsonTag = field.Name
		}
		if _, exists := rawMap[jsonTag]; !exists {
			missingFields = append(missingFields, jsonTag)
		}
	}

	return len(missingFields) == 0, missingFields
}

func main() {
	jsonData := []byte(`{"name":"Alice","age":30}`)
	var user User
	_ = json.Unmarshal(jsonData, &user)

	allMapped, missing := checkAllFieldsMapped(jsonData, &user)
	if !allMapped {
		fmt.Printf("缺失字段: %v\n", missing) // 输出: 缺失字段: [city]
	} else {
		fmt.Println("所有字段均已映射")
	}
}

这种方法更灵活，适合那种不需要严格在解析阶段报错，而是想做后续校验的场景。

方案三：指针字段的简化写法 #

如果你还是倾向于用指针字段的思路，其实也可以简化写法，直接利用指针的nil值判断，只是需要把所有字段改成指针类型，适合结构体字段较少的场景：

type User struct {
	Name *string `json:"name"`
	Age  *int    `json:"age"`
	City *string `json:"city"`
}

// 检查所有字段是否都被赋值（指针不为nil）
func isUserComplete(user User) bool {
	return user.Name != nil && user.Age != nil && user.City != nil
}

总结下来，如果想避免修改结构体字段类型，方案一和方案二更实用，其中方案一适合强校验场景，方案二适合灵活校验的场景。

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