Go语言混合大小写JSON键反序列化报错，类型不匹配问题求助

问题原因分析 #

这个错误的根源在于Go标准库encoding/json的反序列化规则：当解析JSON到结构体时，Unmarshal会优先匹配字段标签或字段名的精确键名，但同时也支持大小写不敏感的匹配。

你的JSON数据里同时存在"a": "str"和"A": 123两个键，而你的结构体字段A用json:"a"标签指定了对应JSON的"a"键。按照规则，Unmarshal会先将"a"的字符串值赋值给A字段，但之后又会把大小写不匹配但字母相同的"A"键也匹配到同一个字段——而A字段是string类型，无法解析数字类型的值，因此触发了json: cannot unmarshal number into Go struct field TMP.a of type string错误。

解决方案 #

根据你的需求，有几种不同的处理方式：

1. 只精确匹配"a"键，忽略"A"键

如果你不需要JSON中的"A"键，可以通过自定义UnmarshalJSON方法来精确控制键的匹配逻辑：

package main

import (
    "encoding/json"
    "fmt"
)

var b = []byte(`{"a": "str", "A": 123}`)

type TMP struct {
    A string `json:"a"`
}

// 自定义反序列化方法，只处理精确的"a"键
func (t *TMP) UnmarshalJSON(data []byte) error {
    // 先解析成原始map，精确获取键值
    rawMap := make(map[string]interface{})
    if err := json.Unmarshal(data, &rawMap); err != nil {
        return err
    }

    // 只处理精确匹配的"a"键
    if val, exists := rawMap["a"]; exists {
        strVal, ok := val.(string)
        if !ok {
            return fmt.Errorf("key 'a' must be a string, got %T", val)
        }
        t.A = strVal
    }

    // 忽略其他键（包括"A"）
    return nil
}

func main() {
    var tmp TMP
    err := json.Unmarshal(b, &tmp)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(tmp.A) // 输出: str
    }
}

2. 同时处理"a"和"A"键（自动转换类型）

如果你需要兼容两种大小写的键，可以在自定义反序列化中处理类型转换，比如把"A"的数字转成字符串：

package main

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

var b = []byte(`{"a": "str", "A": 123}`)

type TMP struct {
    A string `json:"a"`
}

func (t *TMP) UnmarshalJSON(data []byte) error {
    rawMap := make(map[string]interface{})
    if err := json.Unmarshal(data, &rawMap); err != nil {
        return err
    }

    // 优先处理"a"键
    if val, exists := rawMap["a"]; exists {
        strVal, ok := val.(string)
        if !ok {
            return fmt.Errorf("key 'a' must be a string, got %T", val)
        }
        t.A = strVal
    } else if val, exists := rawMap["A"]; exists {
        // 处理"A"键的数字，转成字符串
        numVal, ok := val.(float64) // JSON数字默认解析为float64
        if !ok {
            return fmt.Errorf("key 'A' must be a number, got %T", val)
        }
        t.A = strconv.FormatFloat(numVal, 'f', -1, 64)
    }

    return nil
}

func main() {
    var tmp TMP
    err := json.Unmarshal(b, &tmp)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(tmp.A) // 输出: str
    }
}

3. 使用interface{}兼容多种类型（需后续类型断言）

如果你不确定键值的类型，可以把字段类型改为interface{}，之后再通过类型断言处理：

package main

import (
    "encoding/json"
    "fmt"
)

var b = []byte(`{"a": "str", "A": 123}`)

type TMP struct {
    A interface{} `json:"a"`
}

func main() {
    var tmp TMP
    err := json.Unmarshal(b, &tmp)
    if err != nil {
        fmt.Println(err)
    } else {
        // 后续需要判断类型并处理
        switch val := tmp.A.(type) {
        case string:
            fmt.Println("String value:", val)
        case float64:
            fmt.Println("Number value:", val)
        }
    }
}

补充说明 #

默认情况下encoding/json的大小写不敏感匹配是为了兼容一些不规范的JSON数据，但当JSON中存在多个大小写不同的同名字键时，就会出现这种冲突问题。自定义反序列化方法是最灵活的解决方案，可以完全控制键的匹配逻辑。

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