Go中如何处理可为数组或字符串的字段反序列化问题？

你碰到的这个问题太常见了——Go的JSON反序列化对类型一致性要求很严，当JSON里同一个字段一会儿是字符串、一会儿是数组时，直接用string类型接收肯定会报错。这里有两种实用的解决方式，你可以根据需求选：

方法一：自定义类型实现json.Unmarshaler接口（推荐） #

这种方式最优雅，把兼容逻辑封装在自定义类型里，后续复用起来特别方便。

首先，定义一个专门处理License的自定义类型，然后实现UnmarshalJSON方法，让它能同时处理字符串和数组两种情况：

import (
    "encoding/json"
    "strings"
)

// 自定义License类型，用于兼容字符串或数组格式的许可证
type LicenseString string

func (ls *LicenseString) UnmarshalJSON(data []byte) error {
    // 先尝试解析成单个字符串
    var singleLicense string
    if err := json.Unmarshal(data, &singleLicense); err == nil {
        *ls = LicenseString(singleLicense)
        return nil
    }

    // 解析字符串失败的话，再尝试解析成字符串数组
    var multiLicenses []string
    if err := json.Unmarshal(data, &multiLicenses); err != nil {
        return err // 两种类型都解析失败，返回原始错误
    }

    // 这里可以按你的需求处理数组，比如用逗号拼接成单个字符串
    *ls = LicenseString(strings.Join(multiLicenses, ", "))
    return nil
}

接下来，修改你的Dependency结构体，把License字段换成这个自定义类型，同时别忘了加JSON标签对应字段名：

type Dependency struct {
    Name    string
    URL     string `json:"repository"` // 对应JSON里的repository字段
    Version string // 后续从key中拆分版本号
    License LicenseString `json:"licenses"`
}

最后调整反序列化代码，直接把JSON数据反序列化为map[string]Dependency即可：

var dependencies map[string]Dependency
err := json.Unmarshal(file, &dependencies)
if err != nil {
    // 处理错误逻辑
}

var result []Dependency
for key, dep := range dependencies {
    // 从key中拆分名称和版本，比如"@babel/code-frame@7.0.0"
    parts := strings.Split(key, "@")
    if len(parts) >= 3 {
        dep.Name = "@" + parts[1] // 提取带scope的包名
        dep.Version = parts[2]    // 提取版本号
    }
    result = append(result, dep)
}

方法二：用中间结构体+类型断言处理 #

如果不想修改原有的Dependency结构体类型，可以先定义一个中间结构体，用interface{}接收licenses字段，之后通过类型断言转换：

// 中间结构体，用来接收原始JSON数据
type rawDependency struct {
    Licenses     interface{} `json:"licenses"`
    Repository   string      `json:"repository"`
    // 其他需要的字段按需添加
}

// 你的原有Dependency结构体保持不变
type Dependency struct {
    Name    string
    URL     string
    Version string
    License string
}

// 反序列化逻辑
dependencies := map[string]*json.RawMessage{}
err := json.Unmarshal(file, &dependencies)
if err != nil {
    // 处理错误
}

var result []Dependency
for key, rawMsg := range dependencies {
    var rawDep rawDependency
    err := json.Unmarshal(*rawMsg, &rawDep)
    if err != nil {
        // 跳过错误的依赖，或者做其他处理
        continue
    }

    // 处理License字段的类型兼容
    var license string
    switch val := rawDep.Licenses.(type) {
    case string:
        license = val
    case []interface{}:
        // 把数组中的元素转为字符串并拼接
        var licenseStrs []string
        for _, item := range val {
            if s, ok := item.(string); ok {
                licenseStrs = append(licenseStrs, s)
            }
        }
        license = strings.Join(licenseStrs, ", ")
    }

    // 从key拆分名称和版本
    parts := strings.Split(key, "@")
    name, version := "", ""
    if len(parts) >=3 {
        name = "@" + parts[1]
        version = parts[2]
    }

    // 组装最终的Dependency对象
    result = append(result, Dependency{
        Name:    name,
        URL:     rawDep.Repository,
        Version: version,
        License: license,
    })
}

小提醒 #

• 一定要给结构体字段加正确的json标签，否则反序列化时会取不到对应的值。
• 拆分依赖名称和版本时，要注意带scope的包名格式（比如@babel/code-frame），调整拆分逻辑适配。
• 如果JSON数组里出现非字符串元素，记得加额外的错误处理逻辑避免panic。

内容的提问来源于stack exchange，提问作者Luís Soares