如何编组一个byte / uint8数组作为JSON数组？ [英] How to marshal a byte/uint8 array as json array in Go?

问题描述

我有一个带有 [] uint8 成员的结构体，我用 json.Marshal 。麻烦的是，它将 uint8 s解释为 char s，并输出一个字符串而不是数组。

如果它是 [] int ，我可以得到它的工作，但我不想如果我可以避免它分配和复制的项目。我可以吗？

解决方案

根据 docs ， [] byte 将被编码为Base64字符串。

数组和切片值编码为JSON数组，除了[]字节编码为base64编码的字符串，且无切片编码作为空的JSON对象。

所以我认为你可能需要让你的结构实现 Marshaler 界面通过实现您自己的 MarshalJSON 方法这使得在你的 [] uint8 中有一个更理想的JSON数组编码。

以下例子：

 导入fmt
导入编码/ json
导入字符串
 
类型测试结构{
名称字符串
 Array [] uint8 
} 
 
 func（t * Te st）MarshalJSON（）（[] byte，error）{
 var array string 
 if t.Array == nil {
 array =null
} else {
 array = strings.Join（strings.Fields（fmt.Sprintf（％d，t.Array）），，）
} 
 jsonResult：= fmt.Sprintf（`{ Name：％q，Array：％s}`，t.Name，array）
 return [] byte（jsonResult），nil 
} 
 
 func main ）{
t：=& Test {Go，[] uint8 {'h'，'e'，'l'，'l'，'o'}} 
 
m， err：= json.Marshal（t）
 if err！= nil {
 fmt.Println（err）
} 
 fmt.Printf（％s，m）/ / {Name：Go，Array：[104,101,108,108,111]} 
} 
  

http://play.golang.org/p/Tip59Z9gqs

---

或者一个更好的方法是创建一个新类型，它具有 [] uint8 作为其基础类型，使该类型为 Marshaler ，并在您的结构中使用该类型

 导入fmt
导入编码/ json
导入字符串
 
类型JSONableSlice [] uint8 
 
 func（u JSONableSlice）MarshalJSON（）（[] byte，error）{
 var结果字符串
 if u == nil {
 result =null
} else {
 result = strings.Join（strings.Fields（fmt.Sprintf（％d，u）），，）
} 
 return [] byte（result），nil 
} 
 
类型测试结构{
名称字符串
数组JSONableSlice 
 } 
 
 func main（）{
t：=& Test {Go，[] uint8 {'h'，'e'，'l'，'l'，'o '}} 
 $ bm，err：= json.Marshal（t）
 if err！= nil {
 fmt.Println（err）
} 
 fmt.Printf（％s，m）// {Name：Go，Array：[104,101,108,108,111]} 
} 
  

http://play.golang.org/p / 6aURXw8P5d

I've got a struct with a []uint8 member and I'm writing it with json.Marshal. Trouble is, it's interpreting the uint8s as chars and it outputs a string rather than an array of numbers.

I can get this to work if it's a []int, but I don't want to have to allocate and copy over the items if I can avoid it. Can I?

解决方案

According to the docs, a []byte will be encoded as a Base64 string.

"Array and slice values encode as JSON arrays, except that []byte encodes as a base64-encoded string, and a nil slice encodes as the null JSON object."

So I think that you may need to make your struct implement the Marshaler interface by implementing your own MarshalJSON method that makes a more desirable JSON array encoding out of your []uint8.

Take this example:

import "fmt"
import "encoding/json"
import "strings"

type Test struct {
    Name  string
    Array []uint8
}

func (t *Test) MarshalJSON() ([]byte, error) {
    var array string
    if t.Array == nil {
        array = "null"
    } else {
        array = strings.Join(strings.Fields(fmt.Sprintf("%d", t.Array)), ",")
    }
    jsonResult := fmt.Sprintf(`{"Name":%q,"Array":%s}`, t.Name, array)
    return []byte(jsonResult), nil
}

func main() {
    t := &Test{"Go", []uint8{'h', 'e', 'l', 'l', 'o'}}

    m, err := json.Marshal(t)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Printf("%s", m) // {"Name":"Go","Array":[104,101,108,108,111]}
}

http://play.golang.org/p/Tip59Z9gqs

---

Or maybe a better idea would be to make a new type that has []uint8 as its underlying type, make that type a Marshaler, and use that type in your struct.

import "fmt"
import "encoding/json"
import "strings"

type JSONableSlice []uint8

func (u JSONableSlice) MarshalJSON() ([]byte, error) {
    var result string
    if u == nil {
        result = "null"
    } else {
        result = strings.Join(strings.Fields(fmt.Sprintf("%d", u)), ",")
    }
    return []byte(result), nil
}

type Test struct {
    Name  string
    Array JSONableSlice
}

func main() {
    t := &Test{"Go", []uint8{'h', 'e', 'l', 'l', 'o'}}

    m, err := json.Marshal(t)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Printf("%s", m) // {"Name":"Go","Array":[104,101,108,108,111]}
}

http://play.golang.org/p/6aURXw8P5d

这篇关于如何编组一个byte / uint8数组作为JSON数组？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！