在 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 “显式优于隐式”哲学的典型体现。
