Json and Go

Reference https://blog.go-zh.org/json-a…
Encoding
Encode的基本用法是
package main

import (
“encoding/json”
“fmt”
“os”
)

type Message struct {
Name string
Body string
Time int64
}

func main() {
message := Message{“Tom”, “Hello”, 1294706395881547000}
b, err := json.Marshal(message)
if err != nil {
fmt.Fprintf(os.Stderr, “Failed to Marshal!”)
os.Exit(1)
}

fmt.Printf(“%s”, b)
}
输出为:
{“Name”:”Tom”,”Body”:”Hello”,”Time”:1294706395881547000}
func Marshal(v interface{}) ([]byte, error)
Only data structures that can be represented as valid JSON will be encoded:

JSON objects only support string as keys.

Channel, complex, and function types cannot be encoded.
Cyclic data structures are not supported.
Pointers will be encoded as the values they point to(or null if the pointer is nil)

json package 只能access the exportede fields. 也就是首字母大写的field. 也就是在data structure中的首字母大写的field才会present in JSON output
Decoding
// We must first create a place where the decoded data will be stored
var output Message
// Please note that passing the pointer to output
decodeErr := json.Unmarshal(b, &output)
if decodeErr != nil {
fmt.Fprintf(os.Stderr, “Failed to Unmarshal json data!err:%s”, err)
os.Exit(1)
}

fmt.Printf(“%+v\n”, output)
Unmarshal是怎么确认json field与data structure的对应关系呢？，其实是通过以下来判断的(优先级从高到低).比如对于JSON Field “Foo”来说，

An exported field with a tag of “Foo”.
An exported field named “Foo”
An exported field named “FOO” or “FoO” or some other case-insensitive match of “Foo”

总结下来是: Tag -> Foo -> FOO(case-insensitive match)tag的判定规则如下
// Field appears in JSON as key “myName”.
Field int `json:”myName”`

// Field appears in JSON as key “myName” and
// the field is omitted from the object if its value is empty,
// as defined above.
Field int `json:”myName,omitempty”`

// Field appears in JSON as key “Field” (the default), but
// the field is skipped if empty.
// Note the leading comma.
Field int `json:”,omitempty”`

// Field is ignored by this package.
Field int `json:”-“`

// Field appears in JSON as key “-“.
Field int `json:”-,”`
如果json data 与data structure中只有部分field匹配怎么办？
var unmatchedOutput UnmatchMessage
message1 :=
//` `代表原生字符串面值，没有转义操作，全是字符串的字面值
[]byte{`{“Name”:”Tom”,”Body”:”Hello”,”Time”:1294706395881547000}`}
decodeErr1 := json.Unmarshal(b, &unmatchedOutput)
if decodeErr1 != nil {
fmt.Fprintf(os.Stderr, “Failed to unmarshal json data! err:”, err)
os.Exit(1)
}
fmt.Printf(“%+v\n”, unmatchedOutput)
输出为
{Name:Tom Boy: Tim:0}
从上看出，Unmarshal只会decode符合上述3条件的field！This behavior is particularly useful when you wish to pick only a few specific fields out of a large JSON blob.
Generic JSON with interface{}
Decoding arbitrary data
以上2章先跳过去
Reference Types
Unmarshal会为Reference Types自动allocated a memory. 注意这里仅仅为在json 中存在的data allocate memory.
package main

import (
“encoding/json”
“fmt”
“os”
)

type FamilyMember struct {
Name string
Age int
Parents []string
}

func main() {
family := FamilyMember{“Andy”, 26, []string{“Tom”, “Lucy”}}
b, err := json.Marshal(family)
if err != nil {
fmt.Fprintf(os.Stderr, “Failed to Marshal family!err:%s”, err)
os.Exit(1)
}

fmt.Printf(“%s\n”, b)

// 注意，此时Parents slice是nil. 在Unmarshal时，会自动为其allcated memory.
var output FamilyMember
decodeErr := json.Unmarshal(b, &output)
if decodeErr != nil {
fmt.Fprintf(os.Stderr, “Failed to unmarshal!err:%s”, err.Error())
os.Exit(1)
}

fmt.Printf(“%+v\n”, output)
}
对于指针也是一样的
package main

import (
“encoding/json”
“fmt”
“os”
)

type Bar int
type Foo struct {
Bar *Bar
}

func main() {
b := []byte(`{“Bar”:1234}`)
var data Foo
err := json.Unmarshal(b, &data)
if err != nil {
fmt.Fprintf(os.Stderr, “Failed to unmarshal!err:%s”, err.Error())
os.Exit(1)
}
fmt.Printf(“%+v\n”, data)
fmt.Printf(“%+v\n”, *(data.Bar))
}
输出为：
{Bar:0xc42001a120} // 注意此时的地址不为nil了，因为在Unmarshal已经为其allocated了memory
1234
但是需要注意，Unmarshal只会为json data匹配的field 分配内存，对于没有匹配的，可能还是nil. 所以对于如下的structure，在使用之前还需要认为的判断是否为nil.
type IncomingMessage struct {
Cmd *Command
Msg *Message
}
Streaming Encoders and Decoders
package main

import (
“encoding/json”
“log”
“os”
)

func main() {
dec := json.NewDecoder(os.Stdin)
enc := json.NewEncoder(os.Stdout)
for {
var v map[string]interface{}
if err := dec.Decode(&v); err != nil {
log.Println(err)
return
}
for k := range v {
if k != “Name” {
delete(v, k)
}
}
if err := enc.Encode(&v); err != nil {
log.Println(err)
}
}
}