Go语言中将[]uint8或[]byte序列化为JSON数字数组的策略

package main

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

// Test 结构体包含一个字符串字段和一个[]uint8字段
type Test struct {
    Name  string
    Array []uint8
}

// MarshalJSON 为Test类型实现json.Marshaler接口
func (t *Test) MarshalJSON() ([]byte, error) {
    var arrayStr string
    if t.Array == nil {
        // 如果切片为nil，则JSON表示为null
        arrayStr = "null"
    } else {
        // 将[]uint8转换为形如 "[104 101 108 108 111]" 的字符串
        // strings.Fields会将其分割成 [" [104", "101", "108", "108", "111] "]
        // strings.Join再用逗号连接，得到 "[104,101,108,108,111]"
        arrayStr = strings.Join(strings.Fields(fmt.Sprintf("%d", t.Array)), ",")
    }

    // 使用fmt.Sprintf构建最终的JSON字符串
    // %q 格式化字符串为带双引号的JSON字符串
    // %s 格式化arrayStr为原始字符串，因为arrayStr已经包含了JSON数组的括号
    jsonResult := fmt.Sprintf(`{"Name":%q,"Array":%s}`, t.Name, arrayStr)
    return []byte(jsonResult), nil
}

func main() {
    // 示例1: 包含有效[]uint8的结构体
    t1 := &Test{"Go", []uint8{'h', 'e', 'l', 'l', 'o'}}
    m1, err := json.Marshal(t1)
    if err != nil {
        fmt.Println("Error marshaling t1:", err)
    }
    fmt.Printf("Marshaled t1: %s\n", m1) // {"Name":"Go","Array":[104,101,108,108,111]}

    // 示例2: 包含nil []uint8的结构体
    t2 := &Test{"NilArray", nil}
    m2, err := json.Marshal(t2)
    if err != nil {
        fmt.Println("Error marshaling t2:", err)
    }
    fmt.Printf("Marshaled t2: %s\n", m2) // {"Name":"NilArray","Array":null}

    // 示例3: 包含空[]uint8的结构体 (空切片与nil切片不同)
    t3 := &Test{"EmptyArray", []uint8{}}
    m3, err := json.Marshal(t3)
    if err != nil {
        fmt.Println("Error marshaling t3:", err)
    }
    fmt.Printf("Marshaled t3: %s\n", m3) // {"Name":"EmptyArray","Array":[]}
}

package main

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

// JSONableUint8Slice 是一个基于[]uint8的自定义类型
type JSONableUint8Slice []uint8

// MarshalJSON 为JSONableUint8Slice类型实现json.Marshaler接口
func (u JSONableUint8Slice) MarshalJSON() ([]byte, error) {
    var result string
    if u == nil {
        // 如果切片为nil，则JSON表示为null
        result = "null"
    } else {
        // 逻辑与策略一相同，将[]uint8转换为JSON数字数组字符串
        result = strings.Join(strings.Fields(fmt.Sprintf("%d", u)), ",")
    }
    return []byte(result), nil
}

// AnotherTest 结构体使用自定义的JSONableUint8Slice类型
type AnotherTest struct {
    Name  string
    Data  JSONableUint8Slice
    Value int
}

func main() {
    // 示例1: 包含有效数据的结构体
    at1 := &AnotherTest{"GoLang", []uint8{'w', 'o', 'r', 'l', 'd'}, 123}
    m1, err := json.Marshal(at1)
    if err != nil {
        fmt.Println("Error marshaling at1:", err)
    }
    fmt.Printf("Marshaled at1: %s\n", m1) // {"Name":"GoLang","Data":[119,111,114,108,100],"Value":123}

    // 示例2: 包含nil切片的结构体
    at2 := &AnotherTest{"NilData", nil, 456}
    m2, err := json.Marshal(at2)
    if err != nil {
        fmt.Println("Error marshaling at2:", err)
    }
    fmt.Printf("Marshaled at2: %s\n", m2) // {"Name":"NilData","Data":null,"Value":456}
}