本文介绍如何在 Go 中优雅处理同一 JSON 字段（如 "people"）可能为对象（map）或数组（slice）的动态结构，通过 interface{} + 类型断言 + 二次反序列化实现单类型适配，兼顾类型安全与代码简洁性。
本文介绍如何在 go 中优雅处理同一 json 字段（如 `"people"`）可能为对象（map）或数组（slice）的动态结构，通过 `interface{}` + 类型断言 + 二次反序列化实现单类型适配，兼顾类型安全与代码简洁性。
在实际开发中，我们常需对接第三方 API，而其返回的 JSON 结构可能不统一——例如字段 "people" 有时是键值对形式的对象（如 {"admin": {...}, "user": {...}}），有时却是人员列表数组（如 [{"name":"..."},{"name":"..."}]）。Go 的 encoding/json 包默认要求强类型匹配，无法直接用单一结构体同时兼容这两种形态。但借助 Go 的接口机制与运行时类型判断，我们可以构建健壮、可维护的解析方案。
✅ 推荐方案：一次 Unmarshal 到 interface{}，再按类型分支处理
核心思路是先解码为通用容器 interface{}，再通过类型断言识别底层结构（map[string]interface{} 或 []interface{}），最后分别反序列化为对应结构体。这种方式避免了重复解析、保持逻辑清晰，且完全兼容标准库行为。
以下是一个完整可运行示例：
package main
import (
"encoding/json"
"fmt"
"log"
)
type Person struct {
Name string `json:"name,omitempty"`
Address string `json:"address,omitempty"` // 注意：原问题中拼写为 "adress"，此处修正为标准拼写
Pet string `json:"pet,omitempty"`
}
// People 是统一入口类型，支持两种 JSON 形态
type People struct {
Admin *Person `json:"admin,omitempty"`
User *Person `json:"user,omitempty"`
List []*Person `json:"-"` // 不参与直接 JSON 映射
Raw json.RawMessage `json:"people"` // 延迟解析，保留原始字节
}
// UnmarshalJSON 实现自定义反序列化逻辑
func (p *People) UnmarshalJSON(data []byte) error {
// 1. 先提取 "people" 字段原始数据（避免预解析失败）
var raw map[string]json.RawMessage
if err := json.Unmarshal(data, &raw); err != nil {
return err
}
peopleData, ok := raw["people"]
if !ok {
return fmt.Errorf(`missing field "people"`)
}
// 2. 尝试解析为对象（map）：检查是否以 '{' 开头
if len(peopleData) > 0 && peopleData[0] == '{' {
var obj map[string]json.RawMessage
if err := json.Unmarshal(peopleData, &obj); err != nil {
return err
}
// 分别解析 admin/user 子字段（若存在）
if adminData, found := obj["admin"]; found {
p.Admin = &Person{}
if err := json.Unmarshal(adminData, p.Admin); err != nil {
return fmt.Errorf("failed to unmarshal admin: %w", err)
}
}
if userData, found := obj["user"]; found {
p.User = &Person{}
if err := json.Unmarshal(userData, p.User); err != nil {
return fmt.Errorf("failed to unmarshal user: %w", err)
}
}
return nil
}
// 3. 否则尝试解析为数组（slice）
if len(peopleData) > 0 && peopleData[0] == '[' {
var list []*Person
if err := json.Unmarshal(peopleData, &list); err != nil {
return err
}
p.List = list
return nil
}
return fmt.Errorf(`invalid "people" value: neither object nor array`)
}
// 使用示例
func main() {
// Type 1: Object form
json1 := []byte(`{
"people": {
"admin": {"name": "John Smith", "address": "123 main street"},
"user": {"name": "Jane Doe", "address": "321 broad street"}
}
}`)
// Type 2: Array form
json2 := []byte(`{
"people": [
{"name": "Jon Snow", "pet": "Ghost"},
{"name": "Sansa Stark", "pet": "Lady"}
]
}`)
for i, data := range [][]byte{json1, json2} {
var p People
if err := json.Unmarshal(data, &p); err != nil {
log.Fatalf("Case %d parse failed: %v", i+1, err)
}
fmt.Printf("Case %d → Admin: %+v, User: %+v, ListLen: %d\n",
i+1, p.Admin, p.User, len(p.List))
}
}
⚠️ 关键注意事项
- json.RawMessage 是关键：它延迟解析，避免在首次 Unmarshal 时因类型不匹配而 panic，同时保留原始字节供后续精准处理。
- 字段名大小写与标签一致性：确保结构体字段标签（如 json:"name"）与 JSON 键名严格匹配；注意原问题中 "adress" 拼写错误，应统一为 "address" 以符合常规实践。
- 空值与缺失字段处理：使用 omitempty 标签可忽略零值字段输出，但在解析时建议显式初始化指针（如 p.Admin = &Person{}）再反序列化，防止 nil 解引用 panic。
- 性能考量：该方案仅多一次内存拷贝（RawMessage），在绝大多数 API 场景下开销可忽略；若极致追求性能，可结合 unsafe 或预分配缓冲区优化，但通常不必要。
✅ 总结
面对 JSON 字段类型不确定的场景，不应强行设计“万能结构体”，而应拥抱 Go 的类型系统本质：用接口抽象共性，用断言识别差异，用组合封装逻辑。上述 UnmarshalJSON 自定义方法既保持了调用侧的简洁性（json.Unmarshal(data, &p)），又实现了对异构数据的鲁棒解析，是生产环境中推荐的标准实践。
