Go語言自帶的encode/json包提供了對JSON數據格式的編碼和解碼能力。之前的文章《
如何控制Go編碼JSON數據格式的行為
》已經介紹了編碼JSON時常見的幾個問題，如何使用encode/json來解決。解碼JSON時encode/json包使用UnMarshall或者Decode方法根據開發者提供的存放解碼後數據的變量的類型聲明來解析JSON並把解碼後的數據填充到Go變量裡。所以解析JSON的關鍵其實是如何聲明存放解析後數據的變量的類型。
由於JSON格式的自由組合的特點，對新手來說通過觀察JSON數據的內容，聲明解析後數據的類型還是挺困難的。反正我剛用Go開始做項目時面對數據庫之前的一個複雜的JSON研究了一天才解析出來（也有我那會太菜的原因，被逼無奈看了兩天語法，就直接開始用Go寫項目了）。所以我花時間總結了一下常見的幾類JSON數據組合模式應該如何聲明解析數據的類型，以及UnMarshal和Decode兩個解碼函數的用法。
文章主題內容是很早以前發在思否上的一篇文章，後來授權給了Go語言中文網的站長。那會兒我還覺得公眾號不適合寫技術文章。回看之前那篇文章感覺有的地方文字表達的方式不太好，這跟自己對語言的熟悉程度也有關。
我們先從最簡單的JSON數據內容開始介紹，一點點增加JSON數據內容的複雜度。
解析簡單JSON
先觀察下這段JSON數據的組成，name，created是字符串。id是整型，fruit是一個字符串數組
<code>{
"name": "Standard",
"fruit": [
"Apple",
"Banana",
"Orange"
],
"id": 999,
"created": "2018-04-09T23:00:00Z"
}
/<code>那麼對應的在Go裡面解析數據的類型應該被聲明為：
<code>type FruitBasket struct {
Name string `json:"name"`
Fruit []string `json:"fruit"`
Id int64 `json:"id"`
Created time.Time `json:"created"`
}
/<code>完整的解析JSON的代碼如下：
<code>package main
import (
"fmt"
"encoding/json"
"time"
)
func main() {
type FruitBasket struct {
Name string `json:"name"`
Fruit []string `json:"fruit"`
Id int64 `json:"id"`
Created time.Time `json:"created"`
}
jsonData := []byte(`
{
"name": "Standard",
"fruit": [
"Apple",
"Banana",
"Orange"
],
"id": 999,
"created": "2018-04-09T23:00:00Z"
}`)
var basket FruitBasket
err := json.Unmarshal(jsonData, &basket)
if err != nil {
fmt.Println(err)
}
fmt.Println(basket.Name, basket.Fruit, basket.Id)
fmt.Println(basket.Created)
}
/<code>說明：由於json.UnMarshal()方法接收的是字節切片，所以首先需要把JSON字符串轉換成字節切片c := []byte(s)
解析內嵌對象的JSON
把上面的fruit鍵對應的值如果改成字典 變成"fruit" : {"name":"Apple", "priceTag":"$1"}：
<code> jsonData := []byte(`
{
"name": "Standard",
"fruit" : {"name": "Apple", "priceTag": "$1"},
"def": 999,
"created": "2018-04-09T23:00:00Z"
}`)
/<code>那麼Go語言裡存放解析數據的類型應該這麼聲明
<code>type Fruit struct {
Name string `json":name"`
PriceTag string `json:"priceTag"`
}
type FruitBasket struct {
Name string `json:"name"`
Fruit Fruit `json:"fruit"`
Id int64 `json:"id"`
Created time.Time `json:"created"`
}
/<code>解析內嵌對象數組的JSON
如果上面JSON數據裡的Fruit值現在變成了
<code>"fruit" : [
{
"name": "Apple",
"priceTag": "$1"
},
{
"name": "Pear",
"priceTag": "$1.5"
}
]
/<code>這種情況也簡單把存放解析後數據的類型其聲明做如下更改，把Fruit字段類型換為 []Fruit即可
<code>type Fruit struct {
Name string `json:"name"`
PriceTag string `json:"priceTag"`
}
type FruitBasket struct {
Name string `json:"name"`
Fruit []Fruit `json:"fruit"`
Id int64 `json:"id"`
Created time.Time `json:"created"`
}
/<code>解析具有動態Key的對象
下面再做一下複雜的變化，如果把上面的對象數組變為以Fruit的Id作為屬性名的複合對象（object of object）比如：
<code>"Fruit" : {
"1": {
"Name": "Apple",
"PriceTag": "$1"
},
"2": {
"Name": "Pear",
"PriceTag": "$1.5"
}
}
/<code>每個Key的名字在聲明類型的時候是不知道值的，這樣該怎麼聲明呢，答案是把Fruit字段的類型聲明為一個Key為string類型值為Fruit類型的map
<code>type Fruit struct {
Name string `json:"name"`
PriceTag string `json:"priceTag"`
}
type FruitBasket struct {
Name string `json:"name"`
Fruit map[string]Fruit `json:"fruit"`
Id int64 `json:"id"`
Created time.Time `json:"created"`
}
/<code>可以運行下面完整的代碼段試一下。
<code>package main
import (
"fmt"
"encoding/json"
"time"
)
func main() {
type Fruit struct {
Name string `json:"name"`
PriceTag string `json:"priceTag"`
}
type FruitBasket struct {
Name string `json:"name"`
Fruit map[string]Fruit `json:"fruit"`
Id int64 `json:"id"`
Created time.Time `json:"created"`
}
jsonData := []byte(`
{
"Name": "Standard",
"Fruit" : {
"1": {
"name": "Apple",
"priceTag": "$1"
},
"2": {
"name": "Pear",
"priceTag": "$1.5"
}
},
"id": 999,
"created": "2018-04-09T23:00:00Z"
}`)
var basket FruitBasket
err := json.Unmarshal(jsonData, &basket)
if err != nil {
fmt.Println(err)
}
for _, item := range basket.Fruit {
fmt.Println(item.Name, item.PriceTag)
}
}
/<code>解析包含任意層級的數組和對象的JSON數據
針對包含任意層級的JSON數據，encoding/json包使用：
- map[string]interface{} 存儲JSON對象
- []interface 存儲JSON數組
json.Unmarshl 將會把任何合法的JSON數據存儲到一個interface{}類型的值，通過使用空接口類型我們可以存儲任意值，但是使用這種類型作為值時需要先做一次類型斷言。
<code>jsonData := []byte(`{"Name":"Eve","Age":6,"Parents":["Alice","Bob"]}`)
var v interface{}
json.Unmarshal(jsonData, &v)
data := v.(map[string]interface{})
for k, v := range data {
switch v := v.(type) {
case string:
fmt.Println(k, v, "(string)")
case float64:
fmt.Println(k, v, "(float64)")
case []interface{}:
fmt.Println(k, "(array):")
for i, u := range v {
fmt.Println(" ", i, u)
}
default:
fmt.Println(k, v, "(unknown)")
}
}
/<code>雖然將JSON數據存儲到空接口類型的值中可以用來解析任意結構的JSON數據，但是在實際應用中發現還是有不可控的地方，比如將數字字符串的值轉換成了float類型的值，所以經常會在運行時報類型斷言的錯誤，所以在JSON結構確定的情況下還是優先使用結構體類型聲明，將JSON數據到結構體中的方式來解析JSON。
用 Decoder解析數據流
上面都是使用的UnMarshall解析的JSON數據，如果JSON數據的載體是打開的文件或者HTTP請求體這種數據流（他們都是io.Reader的實現），我們不必把JSON數據讀取出來後再去調用encode/json包的UnMarshall方法，包提供的Decode方法可以完成讀取數據流並解析JSON數據最後填充變量的操作。
<code>// This example uses a Decoder to decode a stream of distinct JSON values.
func ExampleDecoder() {
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)
}
// Output:
// Ed: Knock knock.
// Sam: Who's there?
// Ed: Go fmt.
// Sam: Go fmt who?
// Ed: Go fmt yourself!
}
/<code>
