json?
json大家都不陌生：?
JSON(JavaScript Object Notation, JS 對象標記) 是一種輕量級的數據交換格式。它基于 ECMAScript 規范的一個子集，采用完全獨立于編程語言的文本格式來存儲和表示數據。簡潔和清晰的層次結構使得 JSON 成為理想的數據交換語言。 易于人閱讀和編寫，同時也易于機器解析和生成，并有效地提升網絡傳輸效率。

encoding/json?
c++中我們使用json11進行json相關的操作，但是go語言呢，自帶光環了：?
encoding/json 是Go語言自帶的JSON轉換庫

Marshal

func Marshal(v interface{}) ([]byte, error)

把對象轉換為JSON:?
　　　　? 布爾型轉換為 JSON 后仍是布爾型　， 如true -> true

　　　　? 浮點型和整數型轉換后為JSON里面的常規數字，如 1.23 -> 1.23

　　　　? 字符串將以UTF-8編碼轉化輸出為Unicode字符集的字符串，特殊字符比如<將會被轉義為\u003c

　　　　? 數組和切片被轉換為JSON 里面的數組，[]byte類會被轉換為base64編碼后的字符串，slice的零值被轉換為null

　　　　? 結構體會轉化為JSON對象，并且只有結構體里邊以大寫字母開頭的可被導出的字段才會被轉化輸出，而這些可導出的字段會作為JSON對象的字符串索引

　　　　? 轉化一個map 類型的數據結構時，該數據的類型必須是 map[string]T（T 可以是encoding/json 包支持的任意數據類型）

簡單應用：

package mainimport ("encoding/json""fmt""os" )func main() {type ColorGroup struct {ID intName stringColors []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) }

輸出：?
{“ID”:1,”Name”:”Reds”,”Colors”:[“Crimson”,”Red”,”Ruby”,”Maroon”]}

Unmarshal

func Unmarshal(data [] byte, v interface{}) error

把 JSON 轉換回對象的方法:?
這個函數會把傳入的 data 作為一個JSON來進行解析，解析后的數據存儲在參數 v 中。這個參數 v 也是任意類型的參數（但一定是一個類型的指針），原因是我們在是以此函數進行JSON 解析的時候，這個函數不知道這個傳入參數的具體類型，所以它需要接收所有的類型。

簡單應用：

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

輸出：[{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]

Encoders and Decoders

NewDecoder?returns a new decoder that reads from r.

func NewDecoder(r io.Reader) *Decoder

A?Decoder?reads and decodes JSON values from an input stream.

type Decoder struct {// contains filtered or unexported fields }

An?Encoder?writes JSON values to an output stream.

type Encoder struct {// contains filtered or unexported fields }

簡單應用：

package mainimport ("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 Messageif err := dec.Decode(&m); err == io.EOF {break} else if err != nil {log.Fatal(err)}fmt.Printf("%s: %s\n", m.Name, m.Text)} }

Encode和Marshal的區別?
func Encode is a method on an Encoder, which writes JSON encoded Go types to an?output stream?(func NewEncoder takes an io.Writer and returns a *Encoder).

Marshal is a function that returns JSON encoding of Go types.

應用

package mainimport "encoding/json" import "fmt" import "os"// We'll use these two structs to demonstrate encoding and // decoding of custom types below. type Response1 struct {Page intFruits []string } type Response2 struct {Page int `json:"page"`Fruits []string `json:"fruits"` }func main() {// First we'll look at encoding basic data types to// JSON strings. Here are some examples for atomic// values.bolB, _ := json.Marshal(true)fmt.Println(string(bolB))intB, _ := json.Marshal(1)fmt.Println(string(intB))fltB, _ := json.Marshal(2.34)fmt.Println(string(fltB))strB, _ := json.Marshal("gopher")fmt.Println(string(strB))// And here are some for slices and maps, which encode// to JSON arrays and objects as you'd expect.slcD := []string{"apple", "peach", "pear"}slcB, _ := json.Marshal(slcD)fmt.Println(string(slcB))mapD := map[string]int{"apple": 5, "lettuce": 7}mapB, _ := json.Marshal(mapD)fmt.Println(string(mapB))// The JSON package can automatically encode your// custom data types. It will only include exported// fields in the encoded output and will by default// use those names as the JSON keys.res1D := &Response1{Page: 1,Fruits: []string{"apple", "peach", "pear"}}res1B, _ := json.Marshal(res1D)fmt.Println(string(res1B))// You can use tags on struct field declarations// to customize the encoded JSON key names. Check the// definition of `Response2` above to see an example// of such tags.res2D := &Response2{Page: 1,Fruits: []string{"apple", "peach", "pear"}}res2B, _ := json.Marshal(res2D)fmt.Println(string(res2B))// Now let's look at decoding JSON data into Go// values. Here's an example for a generic data// structure.byt := []byte(`{"num":6.13,"strs":["a","b"]}`)// We need to provide a variable where the JSON// package can put the decoded data. This// `map[string]interface{}` will hold a map of strings// to arbitrary data types.var dat map[string]interface{}// Here's the actual decoding, and a check for// associated errors.if err := json.Unmarshal(byt, &dat); err != nil {panic(err)}fmt.Println(dat)// In order to use the values in the decoded map,// we'll need to cast them to their appropriate type.// For example here we cast the value in `num` to// the expected `float64` type.num := dat["num"].(float64)fmt.Println(num)// Accessing nested data requires a series of// casts.strs := dat["strs"].([]interface{})str1 := strs[0].(string)fmt.Println(str1)// We can also decode JSON into custom data types.// This has the advantages of adding additional// type-safety to our programs and eliminating the// need for type assertions when accessing the decoded// data.str := `{"page": 1, "fruits": ["apple", "peach"]}`res := Response2{}json.Unmarshal([]byte(str), &res)fmt.Println(res)fmt.Println(res.Fruits[0])// In the examples above we always used bytes and// strings as intermediates between the data and// JSON representation on standard out. We can also// stream JSON encodings directly to `os.Writer`s like// `os.Stdout` or even HTTP response bodies.enc := json.NewEncoder(os.Stdout)d := map[string]int{"apple": 5, "lettuce": 7}enc.Encode(d) }

https://play.golang.org/p/WxRgpycMaH

總結

以上是生活随笔為你收集整理的Go语言学习之encoding/json包的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。