Go語言中json序列化的一個小坑，建議多留意一下

左诗右码發表於2024-11-24
GoJSON

在 Go 語言開發中，JSON（JavaScript Object Notation）因其簡潔和廣泛的相容性，通常被用作資料交換的主要序列化格式。然而，當你深入使用 JSON 時，可能會發現它並不總是最佳選擇。

本文將探討 JSON 序列化的一些侷限性，也算是一個小坑吧。並給出一些常用的解決方案。

JSON 序列化的潛在問題

我們先來看一個使用 JSON 進行序列化和反序列化的示例：

package json_demo

import (
    "encoding/json"
    "fmt"
)

func JsonEnDeDemo() {
    d1 := make(map[string]interface{})
    d2 := make(map[string]interface{})

    var (
        age    int     = 18
        name   string  = "Alex"
        height float32 = 1.75
    )

    d1["name"] = name
    d1["age"] = age
    d1["height"] = height

    ret, err := json.Marshal(d1)
    if err != nil {
        fmt.Printf("json.Marshal failed: %v\n", err)
        return
    }
    // json.Marshal: {"age":18,"height":1.75,"name":"Alex"}
    fmt.Printf("json.Marshal: %s\n", string(ret))

    err = json.Unmarshal(ret, &d2)
    if err != nil {
        fmt.Printf("json.Unmarshal failed: %v\n", err)
        return
    }
    // json.Unmarshal: map[age:18 height:1.75 name:Alex]
    fmt.Printf("json.Unmarshal: %v\n", d2)

    // 這裡我們可以發現一個問題：Go 語言中的 json 包在序列化 interface{} 型別時，會將數字型別（整型、浮點型等）都序列化為 float64 型別
    for k, v := range d2 {
        // key: age, value: 18, type:float64
        // key: height, value: 1.75, type:float64
        // key: name, value: Alex, type:string
        fmt.Printf("key: %s, value: %v, type:%T \n", k, v, v)
    }
}

這段程式碼展示瞭如何將一個包含 name、age 和 height 的 Go map 資料結構序列化為 JSON 字串，然後再反序列化回來。看似一切正常，但請注意反序列化後的資料型別變化。

執行程式碼後的輸出可能會讓你感到意外：

json.Marshal: {"age":18,"height":1.75,"name":"Alex"}
json.Unmarshal: map[age:18 height:1.75 name:Alex]
key: age, value: 18, type:float64 
key: height, value: 1.75, type:float64 
key: name, value: Alex, type:string

問題：我們發現，儘管原始資料中 age 是 int 型別，height 是 float32 型別，但經過 JSON 反序列化後，它們全都變成了 float64 型別。

Go 語言中的 encoding/json 包會將所有數字型別（包括整型、浮點型等）都轉換為 float64 ，那麼，有沒有方式可以不讓型別丟失呢？還真有！

gob 二進位制協議，高效且保留型別的 Go 專用序列化

為了避免 JSON 的這一侷限性，我們可以使用 Go 語言特有的 GOB 序列化方式。GOB 不僅可以高效地序列化資料，還能夠保留原始資料型別。

以下是使用 GOB 進行序列化和反序列化的示例：

package json_demo

import (
    "bytes"
    "encoding/gob"
    "fmt"
)

func GobEnDeDemo() {
    d1 := make(map[string]interface{})
    d2 := make(map[string]interface{})

    var (
        age    int     = 18
        name   string  = "Alex"
        height float32 = 1.75
    )

    d1["name"] = name
    d1["age"] = age
    d1["height"] = height

    // encode
    buf := new(bytes.Buffer)
    enc := gob.NewEncoder(buf)
    err := enc.Encode(d1)
    if err != nil {
        fmt.Printf("gob.Encode failed: %v\n", err)
        return
    }
    b := buf.Bytes()
    // gob.Encode:  [13 127 4 1 2 255 128 0 1 12 1 16 0 0 57 255 128 0 3 4 110 97 109 101 6 115 116 114 105 110 103 12 6 0 4 65 108 101 120 3 97 103 101 3 105 110 116 4 2 0 36 6 104 101 105 103 104 116 7 102 108 111 97 116 51 50 8 4 0 254 252 63]
    fmt.Println("gob.Encode: ", b)

    // decode
    dec := gob.NewDecoder(bytes.NewBuffer(b))
    err = dec.Decode(&d2)
    if err != nil {
        fmt.Printf("gob.Decode failed: %v\n", err)
        return
    }
    // gob.Decode: map[age:18 height:1.75 name:Alex]
    fmt.Printf("gob.Decode: %v\n", d2)

    for k, v := range d2 {
        // key: name, value: Alex, type:string
        // key: age, value: 18, type:int
        // key: height, value: 1.75, type:float32
        fmt.Printf("key: %s, value: %v, type:%T \n", k, v, v)
    }
}

從上面的程式碼中可以看到，GOB 序列化不僅保留了 age 的 int 型別和 height 的 float32 型別，還能高效地進行資料編碼。這使得 GOB 成為在 Go 程式內部傳遞資料的理想選擇。

第三方包 msgpack

msgpack 是一種高效的二進位制序列化格式，它允許你在多種語言(如JSON)之間交換資料。但它更快更小。

首先需要先下載這個包

go get -v github.com/vmihailenco/msgpack/v5

來看一個使用 msgpack 的示例：

package json_demo

import (
    "fmt"
    "github.com/vmihailenco/msgpack/v5"
)

func MsgpackEnDeDemo() {
    // msgpack 序列化示例
    d1 := make(map[string]interface{})
    d2 := make(map[string]interface{})

    var (
        age    int     = 18
        name   string  = "Alex"
        height float32 = 1.75
    )

    d1["name"] = name
    d1["age"] = age
    d1["height"] = height

    // encode
    b, err := msgpack.Marshal(d1)
    if err != nil {
        fmt.Printf("msgpack.Marshal failed: %v\n", err)
        return
    }
    // msgpack.Marshal:  [131 164 110 97 109 101 164 65 108 101 120 163 97 103 101 18 166 104 101 105 103 104 116 202 63 224 0 0]
    fmt.Println("msgpack.Marshal: ", b)

    // decode
    err = msgpack.Unmarshal(b, &d2)
    if err != nil {
        fmt.Printf("msgpack.Unmarshal failed: %v\n", err)
        return
    }
    // msgpack.Unmarshal: map[age:18 height:1.75 name:Alex]
    fmt.Printf("msgpack.Unmarshal: %v\n", d2)

    for k, v := range d2 {
        // key: age, value: 18, type:int8
        // key: height, value: 1.75, type:float32
        // key: name, value: Alex, type:string
        fmt.Printf("key: %s, value: %v, type:%T \n", k, v, v)
    }

}

msgpack的優勢：

  • 高效緊湊：資料體積比 JSON 更小，序列化和反序列化速度更快。
  • 型別保持：與 GOB 類似，msgpack 也能保持原始資料型別。

總結

  • json：雖然廣泛使用且易於閱讀，但在處理數字型別時有潛在的精度問題。
  • gob：適用於 Go 語言程式內部的資料傳輸，保留型別且效能優異，但僅適用於 Go。
  • msgpack：在需要高效、緊湊的跨語言資料交換時非常有用，同時還能保留資料型別。

透過這三種序列化方式的比較，希望你能夠根據實際需求選擇合適的工具。在需要保證型別和效能的 Go 程式中，gob 和 msgpack 可能是比 json 更好的選擇，不過，你也完全可以使用 json 包來反序列化，只不過取值的時候就需要透過型別斷言來得到之前的型別。

相關文章