Go json Marshal & UnMarshal 的一点小 trick

在编写 Web Service 等涉及数据序列化和反序列化的场景，对于 JSON 类型的数据，在 Go 中我们经常会使用到 encoding/json Package。最近微有所感，小水一篇

omitempty

JSON 数据的 UnMarshal 我们经常会配合 Struct Tags 使用，让 Struct 的 Filed 与 JSON 数据的指定 property 绑定。

如果要序列化为 Go Struct 的 JSON 数据对应的 Fields 相关的 JSON properties 是缺失的，我们经常会用 omitempty 标记 Go Fields，序列化时，JSON 数据中缺少的属性将会被设置为 Go 中对应的 zero-value，比如：

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  string `json:"age,omitempty"`
    Weak bool   `json:"weak,omitempty"`
}

func main() {
    jsonData := `{"name":"ShanSan"}`
    req := Person{}
    _ = json.Unmarshal([]byte(jsonData), &req)
    fmt.Printf("%+v", req)
    fmt.Println(req.Age)
}
// output
// {Name:ShanSan Age: Weak:false}
//

Go Playground Link

但上面的例子对于一些场景的处理可能会有问题。看下下面这个例子：

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  string `json:"age,omitempty"`
    Weak bool   `json:"weak,omitempty"`
}

func main() {
    jsonData := `{"name":"ShanSan", "age": ""}`
    req := Person{}
    _ = json.Unmarshal([]byte(jsonData), &req)
    fmt.Printf("%+v", req)
    fmt.Println(req.Age)
}
// output
// {Name:ShanSan Age: Weak:false}
//

可以看到 age 为 "" 时，和缺省时的结果是一样的。很显然，上面的写法，缺省的字段和空字段是没有被区分开的。对于一些数据的 Update 操作，比如我们只想 Update Name 字段，对应的 JSON 数据为 {"name":"ShanSan"}，执行上述的反序列化动作，Age 字段会被设置为 empty string，Waek 也被设置为了 false，这显然不是我们想看到的。

nil 一下

我们可以指针类型（pointer type）对上面的情况区分一下：

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name *string `json:"name"`
    Age  *string `json:"age,omitempty"`
    Weak *bool   `json:"weak,omitempty"`
}

func main() {
    jsonData := `{"name":"ShanSan"}`
    jsonDataEmptyAge := `{"name":"ShanSan", "age": ""}`
    req := Person{}
    reqEmptyAge := Person{}
    _ = json.Unmarshal([]byte(jsonData), &req)
    _ = json.Unmarshal([]byte(jsonDataEmptyAge), &reqEmptyAge)
    fmt.Printf("%+v", req)
    fmt.Printf("%+v", reqEmptyAge)
}
// {Name:0xc000010390 Age:<nil> Weak:<nil>}{Name:0xc0000103c0 Age:0xc0000103d0 Weak:<nil>}

emmm，缺省的字段为 nil 了。

Marshal 的时候

序列化 struct 的时候，如果使用了 omitempty，也会出现类似上面反序列化的情况，对于缺省的 field 或者 zero-value，序列化得到的 JSON 数据也会缺省相关属性，此时我们也可以通过 pointer 保留相关字段，如下：

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name  string `json:"name"`
    Score int    `json:"score,omitempty"`
}

type StudentWithPointer struct {
    Name  string `json:"name"`
    Score *int   `json:"score,omitempty"`
}

func main() {
    student := Student{
        Name:  "ShanSan",
        Score: 0,
    }

    score := 0
    studentWithPointer := StudentWithPointer{
        Name:  "ShanSan",
        Score: &score,
    }

    data, _ := json.Marshal(student)
    dataWithPointer, _ := json.Marshal(studentWithPointer)
    fmt.Println(string(data))
    fmt.Println(string(dataWithPointer))
}
// {"name":"ShanSan"}
// {"name":"ShanSan","score":0}

Go Playground

参考

• encoding/json
• Differentiate between empty and not-set fields with JSON in Golang
• Go''s "omitempty" explained

本文由博客一文多发平台 OpenWrite 发布！

Go json 自定义 Unmarshal 避免判断 nil

腾讯《Go安全指南》中提到【必须】nil指针判断：进行指针操作时，必须判断该指针是否为nil，防止程序panic，尤其在进行结构体Unmarshal时。但如果每次使用都要判断一下是否 nil 防止 panic的话，那么这样的代码就会比较麻烦，这里我们可以使用一个自定义的方法，来避免这种情况。

使用默认的 Unmarshal 方法

package main

import (
    "encoding/json"
    "fmt"
)

type A struct {
    Name string `json:"name"`
    Num  *int   `json:"num"`
}

func main() {
    var a A
    err := json.Unmarshal([]byte(`{"name": "hsowan"}`), &a)
    if err != nil {
        panic(err)
    }
    fmt.Println(a.Name)
    // 每次使用都要判断一下是否 nil 防止 panic
    if a.Num != nil {
        fmt.Println(*a.Num)
    }
}

自定义的 Unmarshal 方法

当字段为 nil 时，在 Unmarshal 时进行初始化，这样就可以避免使用的时候发生 panic， 同时也不需要在使用的时候判断是否为 nil 了。

package main

import (
    "encoding/json"
    "fmt"
)

type A struct {
    Name string `json:"name"`
    Num  *int   `json:"num"`
}

func (a *A) UnmarshalJSON(b []byte) error {
    type alias A
    aux := (*alias)(a)
    if err := json.Unmarshal(b, &aux); err != nil {
        return err
    }
    if aux.Num == nil {
        aux.Num = new(int)
    }
    return nil
}

func main() {
    var a A
    err := json.Unmarshal([]byte(`{"name": "hsowan"}`), &a)
    if err != nil {
        panic(err)
    }
    fmt.Println(a.Name)
    fmt.Println(*a.Num)
}

参考

• [译]自定义Go Json的序列化方法

go json 解析 Marshal 和 Unmarshal

Decoder:

package main
import (
    "encoding/json"
    "fmt"
    "io"
    "log"
    "strings"
)
func main ( ) {
    const jsonStream = `
        { "Name" : "Ed" , "Text" : "Knock knock." }
        { "Name" : "Sam" , "Text" : "Who''s there?" }
        { "Name" : "Ed" , "Text" : "Go fmt." }
        { "Name" : "Sam" , "Text" : "Go fmt who?" }
        { "Name" : "Ed" , "Text" : "Go fmt yourself!" }
    `
    type Message struct {
        Name , Text string
    }
    dec := json. NewDecoder ( strings. NewReader ( jsonStream ) )
    for {
        var m Message
        if err := dec. Decode ( & m ) ; err == io. EOF {
            break
        } else if err != nil {
            log . Fatal ( err )
        }
        fmt. Printf ( "%s: %s \n " , m. Name , m. Text )
    }
}

Marshal:

package main
import (
    "encoding/json"
    "fmt"
    "os"
)
func main ( ) {
    type ColorGroup struct {
        ID     int
        Name   string
        Colors [ ] string
    }
    group := ColorGroup {
        ID :     1 ,
        Name :   "Reds" ,
        Colors : [ ] string { "Crimson" , "Red" , "Ruby" , "Maroon" } ,
    }
    b , err := json. Marshal ( group )
    if err != nil {
        fmt. Println ( "error:" , err )
    }
    os. Stdout . Write ( b )
}

RawMessage :

package main
import (
    "encoding/json"
    "fmt"
    "log"
)
func main ( ) {
    type Color struct {
        Space string
        Point json. RawMessage // delay parsing until we know the color space
    }
    type RGB struct {
        R uint8
        G uint8
        B uint8
    }
    type YCbCr struct {
        Y   uint8
        Cb int8
        Cr int8
    }
    var j = [ ] byte ( ` [
        { "Space" : "YCbCr" , "Point" : { "Y" : 255 , "Cb" : 0 , "Cr" : - 10 } } ,
        { "Space" : "RGB" ,   "Point" : { "R" : 98 , "G" : 218 , "B" : 255 } }
    ] ` )
    var colors [ ] Color
    err := json. Unmarshal ( j , & colors )
    if err != nil {
        log . Fatalln ( "error:" , err )
    }
    for _ , c := range colors {
        var dst interface { }
        switch c. Space {
        case "RGB" :
            dst = new ( RGB )
        case "YCbCr" :
            dst = new ( YCbCr )
        }
        err := json. Unmarshal ( c. Point , dst )
        if err != nil {
            log . Fatalln ( "error:" , err )
        }
        fmt. Println ( c. Space , dst )
    }
}

Unmarshal:

package main
import (
    "encoding/json"
    "fmt"
)
func main ( ) {
    var jsonBlob = [ ] byte ( ` [
        { "Name" : "Platypus" , "Order" : "Monotremata" } ,
        { "Name" : "Quoll" ,     "Order" : "Dasyuromorphia" }
    ] ` )
    type Animal struct {
        Name  string
        Order string
    }
    var animals [ ] Animal
    err := json. Unmarshal ( jsonBlob , & animals )
    if err != nil {
        fmt. Println ( "error:" , err )
    }
    fmt. Printf ( "%+v" , animals )
}

关于json.Unmarshal将嵌套的对象编入字符串或[] byte和嵌套的json怎么取值的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于Azure 数据流：从 JSON 字符串中解析嵌套的对象列表 将对象数组解析为字符串数组分解字符串数组解析 JSON 字符串收集解析的对象重新加入原始数据结果、Go json Marshal & UnMarshal 的一点小 trick、Go json 自定义 Unmarshal 避免判断 nil、go json 解析 Marshal 和 Unmarshal的相关信息，请在本站寻找。