Go 中序列化混合类型 JSON 数组的完整实践指南_技术教程

在 go 中，需通过实现 `json.marshaler` 和 `json.unmarshaler` 接口，将结构体（如 `row`）按固定顺序序列化为 json 数组（如 `["id", 1.23, "text"]`，绕过 go 类型系统对同构切片的限制。

Go 的静态类型系统不允许直接声明 []interface{} 并混存字符串、浮点数和 Unicode 字符串——这看似与 Python 的 json.dumps() 相比不够灵活。但 Go 提供了优雅的替代方案：自定义序列化逻辑。核心思路是让结构体主动控制其 JSON 表示形式，而非依赖默认反射行为。

✅ 正确做法：实现 json.Marshaler

定义一个 Row 结构体，字段保持语义清晰；再为其添加 MarshalJSON() 方法，内部构造 []interface{} 并委托 json.Marshal 处理：

type Row struct {
    Ooid  string
    Score float64
    Text  string
}

func (r *Row) MarshalJSON() ([]byte, error) {
    // 按目标 JSON 数组顺序组装：[string, float64, string]
    arr := []interface{}{r.Ooid, r.Score, r.Text}
    return json.Marshal(arr)
}

这样，当 json.Marshal([]Row{...}) 被调用时，每个 Row 实例都会被转为长度为 3 的异构 JSON 数组，最终生成符合预期的嵌套结构：

{
  "results": [
    ["ooid1", 2.0, "Söme text"],
    ["ooid2", 1.3, "Åther text"]
  ]
}

完整封装示例（含外层对象）：

type Response struct {
    Results []Row `json:"results"`
}

func main() {
    resp := Response{
        Results: []Row{
            {"ooid1", 2.0, "Söme text"},
            {"ooid2", 1.3, "Åther text"},
        },
    }
    data, _ := json.Marshal(resp)
    fmt.Println(string(data))
    // 输出：{"results":[["ooid1",2,"Söme text"],["ooid2",1.3,"Åther text"]]}
}

? 反向解析：实现 json.Unmarshaler

若需从 JSON 数组反序列化回 Row，同样需实现 UnmarshalJSON()。注意务必加入健壮的错误处理（生产环境不可省略）：

func (r *Row) UnmarshalJSON(data []byte) error {
    var arr []interface{}
    if err := json.Unmarshal(data, &arr); err != nil {
        return fmt.Errorf("failed to unmarshal row as array: %w", err)
    }
    if len(arr) < 3 {
        return fmt.Errorf("row array must have at least 3 elements, got %d", len(arr))
    }

    // 类型断言 + 错误检查
    if s, ok := arr[0].(string); !ok {
        return fmt.Errorf("first element must be string, got %T", arr[0])
    } else {
        r.Ooid = s
    }

    if f, ok := arr[1].(float64); !ok {
        return fmt.Errorf("second element must be float64, got %T", arr[1])
    } else {
        r.Score = f
    }

    if s, ok := arr[2].(string); !ok {
        return fmt.Errorf("third element must be string, got %T", arr[2])
    } else {
        r.Text = s
    }

    return nil
}

使用示例：

text := `[["ooid4", 3.1415, "pi"], ["ooid5", 2.7182, "euler"]]`
var rows []Row
if err := json.Unmarshal([]byte(text), &rows); err != nil {
    log.Fatal(err)
}
fmt.Printf("%+v\n", rows) // [{Ooid:ooid4 Score:3.1415 Text:pi} {Ooid:ooid5 Score:2.7182 Text:euler}]

⚠️ 注意事项与最佳实践

Unicode 安全：string 类型原生支持 UTF-8，无需额外处理（如 rune 字段）；"Söme text" 和 "Åther text" 会正确编码。
性能考量：[]interface{} 是运行时类型擦除容器，存在少量反射开销；若性能极端敏感，可考虑 unsafe 或代码生成（如 easyjson），但绝大多数场景无需过度优化。
错误处理不可省略：示例中简化了错误检查，实际项目中必须验证数组长度、元素类型及转换结果。
避免嵌套结构污染：此方案确保 Row 序列化后是扁平数组而非对象（如 { "Ooid": "...", ... }），完全满足原始需求。

通过 MarshalJSON/UnmarshalJSON 接口，你既能保持 Go 的类型安全与可读性，又能精准控制 JSON 格式——这是 Go “显式优于隐式”哲学的典型体现。