17370845950

go 原生不支持 slice 的混合类型，但可通过实现 `json.marshaler` 和 `json.unmarshaler` 接口，将结构体按固定顺序序列化为 json 数组（如 `["id", 2.5, "文本"]`），完美匹配前端或 api 所需的紧凑格式。

在 Go 中，若需生成形如 { "results": [["ooid1", 2.0, "Söme text"], ["ooid2", 1.3, "Åther text"]] } 的 JSON，关键在于绕过结构体字段名映射默认行为，转而控制序列化输出为位置有序的数组。由于 Go 的 []interface{} 可容纳任意类型，结合 json.Marshaler 接口即可优雅实现。

✅ 正确做法：自定义 MarshalJSON 方法

定义 Row 结构体（字段顺序即 JSON 数组元素顺序），并实现 MarshalJSON() 方法：

type Row struct {
    Ooid  string
    Score float64
    Text  string
}

func (r *Row) MarshalJSON() ([]byte, error) {
    // 按需构造 interface{} 切片，保持类型混合与顺序
    arr := []interface{}{r.Ooid, r.Score, r.Text}
    return json.Marshal(arr)
}

完整示例（含结果嵌套）：

package main

import (
    "encoding/json"
    "fmt"
)

type Row struct {
    Ooid  string
    Score float64
    Text  string
}

func (r *Row) MarshalJSON() ([]byte, error) {
    return json.Marshal([]interface{}{r.Ooid, r.Score, r.Text})
}

func main() {
    data := struct {
        Results []Row `json:"results"`
    }{
        Results: []Row{
            {"ooid1", 2.0, "Söme text"},
            {"ooid2", 1.3, "Åther text"},
        },
    }

    b, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(b))
    // 输出: {"results":[["ooid1",2,"Söme text"],["ooid2",1.3,"Åther text"]]}
}

? 注意：float64 值 2.0 默认序列化为 2（无小数点），如需保留 .0，可改用 fmt.Sprintf("%.1f", r.Score) 转为字符串（但会丢失数值语义，慎用）。

? 反向解析：实现 UnmarshalJSON

若需从 JSON 数组反序列化回 Row，实现 UnmarshalJSON：

func (r *Row) UnmarshalJSON(data []byte) error {
    var arr []interface{}
    if err := json.Unmarshal(data, &arr); err != nil {
        return err
    }
    if len(arr) < 3 {
        return fmt.Errorf("expected 3 elements, got %d", len(arr))
    }

    // 类型断言 + 错误检查（生产环境必需）
    if s, ok := arr[0].(string); ok {
        r.Ooid = s
    } else {
        return fmt.Errorf("Ooid must be string, got %T", arr[0])
    }

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

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

    return nil
}

使用示例：

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

⚠️ 注意事项与最佳实践

• Unicode 安全：Go 的 string 原生支持 UTF-8，"Söme text" 和 "Åther text" 会自动正确编码，无需额外处理。
• 错误处理不可省略：示例中简化了错误检查，实际项目中必须验证 len(arr)、类型断言结果及 json.Unmarshal 返回值。
• 性能考量：[]interface{} 会触发反射和内存分配，高频场景可考虑预分配 []any（Go 1.18+）或使用 unsafe 优化（仅限高级用例）。
• 替代方案权衡：
  • 使用 []any 直接构建（失去结构体语义和字段校验）；
  • 用 map[string]any + 自定义 marshal（但输出为对象而非数组）；
  • 第三方库如 mapstructure 或 ffjson（通常不必要，标准库已足够）。

通过接口定制序列化行为，你既能享受 Go 类型安全的优势，又能灵活输出符合外部系统要求的紧凑 JSON 数组格式——无需妥协，也无需魔改语言。