Go語(yǔ)言使用Json的方法實(shí)現(xiàn)

更新時(shí)間：2024年05月15日 09:37:21 作者：比豬聰明

本文主要介紹了Go語(yǔ)言使用Json的方法實(shí)現(xiàn)

在Go語(yǔ)言中，處理JSON數(shù)據(jù)通常涉及編碼（將Go結(jié)構(gòu)體轉(zhuǎn)換為JSON字符串）和解碼（將JSON字符串轉(zhuǎn)換為Go結(jié)構(gòu)體）。Go標(biāo)準(zhǔn)庫(kù)中的encoding/json包提供了這些功能。第三方插件可以使用"github.com/goccy/go-json"也有同樣的功能

Marshal函數(shù)將會(huì)遞歸遍歷整個(gè)對(duì)象，依次按成員類型對(duì)這個(gè)對(duì)象進(jìn)行編碼，類型轉(zhuǎn)換規(guī)則如下：

bool類型轉(zhuǎn)換為JSON的Boolean
整數(shù)，浮點(diǎn)數(shù)等數(shù)值類型轉(zhuǎn)換為JSON的Number
string 轉(zhuǎn)換為JSON的字符串(帶""引號(hào))
struct 轉(zhuǎn)換為JSON的Object，再根據(jù)各個(gè)成員的類型遞歸打包
數(shù)組或切片轉(zhuǎn)換為JSON的Array
[]byte 會(huì)先進(jìn)行base64編碼然后轉(zhuǎn)換為JSON字符串
map轉(zhuǎn)換為JSON的Object，key必須是string
interface{} 按照內(nèi)部的實(shí)際類型進(jìn)行轉(zhuǎn)換
nil 轉(zhuǎn)為JSON的null
channel,func等類型會(huì)返回UnsupportedTypeError

1、使用標(biāo)準(zhǔn)庫(kù)中的encoding/json包

字符串輸出&格式化輸出&解碼

package main

import (
	"encoding/json"
	"fmt"
)

type ColorGroup struct {
	ID     int
	Name   string
	Colors []string
}

// 創(chuàng)建一個(gè)ColorGroup類型的變量來(lái)保存解碼后的數(shù)據(jù)
var decodedGroup ColorGroup

func main() {
	group := ColorGroup{
		ID:     1,
		Name:   "Reds",
		Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
	}

	// 將結(jié)構(gòu)體編碼為JSON字符串
	jsonData1, err := json.Marshal(group)
	jsonData2, err := json.MarshalIndent(group, "", "	")
	if err != nil {
		fmt.Println("error:", err)
		return
	}

	// 打印JSON字符串
	fmt.Println(string(jsonData1))
	fmt.Println(string(jsonData2))
	// Output:
	//{"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}
	//	{
	//		"ID": 1,
	//		"Name": "Reds",
	//		"Colors": [
	//			"Crimson",
	//			"Red",
	//			"Ruby",
	//			"Maroon"
	//		]
	//	}

	// 將JSON字符串解碼到ColorGroup結(jié)構(gòu)體中
	err = json.Unmarshal([]byte(jsonData1), &decodedGroup)
	if err != nil {
		fmt.Println("error:", err)
		return
	}

	// 打印解碼后的數(shù)據(jù)
	fmt.Printf("ID: %d, Name: %s, Colors: %v\n", decodedGroup.ID, decodedGroup.Name, decodedGroup.Colors)
	// Output: ID: 1, Name: Reds, Colors: [Crimson Red Ruby Maroon]
	fmt.Println(decodedGroup.Colors[0])
	fmt.Println(decodedGroup.Colors[1])
}

2、使用第三方包

標(biāo)準(zhǔn)輸出&格式化輸出&解碼

package main

import (
	"fmt"
	"github.com/goccy/go-json"
	"os"
)

type ColorGroup struct {
	ID     int
	Name   string
	Colors []string
}

func main() {
	group := ColorGroup{
		ID:     1,
		Name:   "Reds",
		Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
	}

	b1, err := json.Marshal(group)
	if err != nil {
		fmt.Println("error:", err)
	}
	println(os.Stdout.Write(b1)) //os.Stdout.Write(b1)將字節(jié)切片b（即JSON字符串的字節(jié)表示）寫入到標(biāo)準(zhǔn)輸出

	fmt.Println("---------------格式化輸出----------------")

	// 使用 MarshalIndent 來(lái)格式化輸出
	b2, err := json.MarshalIndent(group, "", "  ") // 第二個(gè)參數(shù)是空字符串，表示不添加前綴；第三個(gè)參數(shù)是縮進(jìn)字符串
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	// 使用 fmt.Println 來(lái)打印字符串
	// MarshalIndent返回的是字節(jié)切片，我們需要使用string(b2)來(lái)將其轉(zhuǎn)換為字符串
	fmt.Println(string(b2)) // 將字節(jié)切片轉(zhuǎn)換為字符串并打印
	// 輸出將會(huì)是格式化后的 JSON 字符串

	// 創(chuàng)建一個(gè)ColorGroup類型的變量來(lái)保存解碼后的數(shù)據(jù)
	var decodedGroup ColorGroup

	// 將JSON字符串解碼到ColorGroup結(jié)構(gòu)體中
	err = json.Unmarshal([]byte(b1), &decodedGroup)
	if err != nil {
		fmt.Println("error:", err)
		return
	}

	// 打印解碼后的數(shù)據(jù)
	fmt.Printf("ID: %d, Name: %s, Colors: %v\n", decodedGroup.ID, decodedGroup.Name, decodedGroup.Colors)
	// Output: ID: 1, Name: Reds, Colors: [Crimson Red Ruby Maroon]
	fmt.Println(decodedGroup.Colors[0])
	fmt.Println(decodedGroup.Colors[1])
}

請(qǐng)注意，在解碼時(shí)，你需要將JSON字符串轉(zhuǎn)換為[]byte，并且傳入結(jié)構(gòu)體的指針（使用&）。這樣，解碼后的數(shù)據(jù)才會(huì)被寫入到結(jié)構(gòu)體中

3、decode

package main

import (
	"fmt"
	"github.com/goccy/go-json"
)

// Animal 定義結(jié)構(gòu)體來(lái)表示單個(gè)JSON對(duì)象
type Animal struct {
	Name  string
	Order string
}

func main() {

	//創(chuàng)建一個(gè)JSON字節(jié)切片
	var jsonBlob = []byte(`[   
		{"Name": "Platypus", "Order": "Monotremata"},   
		{"Name": "Quoll", "Order": "Dasyuromorphia"}   
	]`)

	var animals []Animal
	err := json.Unmarshal(jsonBlob, &animals)
	if err != nil {
		fmt.Println("error:", err)
	}
	fmt.Printf("%+v", animals)
	fmt.Println()
	// 打印解碼后的數(shù)據(jù)
	for _, animal := range animals {
		fmt.Printf("Name: %s, Order: %s\n", animal.Name, animal.Order)
	}
}

4、注意

結(jié)構(gòu)體

結(jié)構(gòu)體必須是大寫字母開頭的成員才會(huì)被JSON處理到，小寫字母開頭的成員不會(huì)有影響。

Mashal時(shí)，結(jié)構(gòu)體的成員變量名將會(huì)直接作為JSON Object的key打包成JSON；Unmashal時(shí)，會(huì)自動(dòng)匹配對(duì)應(yīng)的變量名進(jìn)行賦值，大小寫不敏感。

Unmarshal時(shí)，如果JSON中有多余的字段，會(huì)被直接拋棄掉；如果JSON缺少某個(gè)字段，則直接忽略不對(duì)結(jié)構(gòu)體中變量賦值，不會(huì)報(bào)錯(cuò)。

package main

import (
	"encoding/json"
	"fmt"
)

type Message struct {
	Name  string
	Body  string
	Time  int64
	inner string
}

func main() {
	var m = Message{
		Name:  "Alice",
		Body:  "Hello",
		Time:  1294706395881547000,
		inner: "ok",
	}
	b := []byte(`{"nAmE":"Bob","Food":"Pickle", "inner":"changed"}`)
	err := json.Unmarshal(b, &m)
	if err != nil {
		fmt.Printf(err.Error())
		return
	}
	fmt.Printf("%v", m)
    //Output: {Bob Hello 1294706395881547000 ok}
}

StructTag/結(jié)構(gòu)體標(biāo)簽

如果希望手動(dòng)配置結(jié)構(gòu)體的成員和JSON字段的對(duì)應(yīng)關(guān)系，可以在定義結(jié)構(gòu)體的時(shí)候給成員打標(biāo)簽：

使用omitempty熟悉，如果該字段為nil或0值（數(shù)字0,字符串"",空數(shù)組[]等），則打包的JSON結(jié)果不會(huì)有這個(gè)字段。

案例一

package main

import (
	"encoding/json"
	"fmt"
)

type Message struct {
	Name string `json:"msg_name"`       // 對(duì)應(yīng)JSON的msg_name
	Body string `json:"body,omitempty"` // 如果為空置則忽略字段
	Time int64  `json:"-"`              // 直接忽略字段
}

func main() {
	var m = Message{
		Name: "Alice",
		Body: "",
		Time: 1294706395881547000,
	}
	data, err := json.Marshal(m)
	if err != nil {
		fmt.Printf(err.Error())
		return
	}
	fmt.Println(string(data))
	//Output:{"msg_name":"Alice"}
}

案例二

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"time"
)

// 定義一個(gè)用于JSON映射的結(jié)構(gòu)體
type User struct {
	Name     string     `json:"username"` // 自定義字段名稱映射
	Email    string     `json:"email"`
	LastSeen CustomTime `json:"last_seen"` // 嵌套對(duì)象
	Active   bool       `json:"-"`         // 忽略此字段，即使JSON中存在也不解碼
}

// CustomTime 是一個(gè)用于表示時(shí)間的結(jié)構(gòu)體
type CustomTime struct {
	time.Time
}

// 實(shí)現(xiàn) json.Unmarshaler 接口的 UnmarshalJSON 方法
func (ct *CustomTime) UnmarshalJSON(data []byte) error {
	var s string
	if err := json.Unmarshal(data, &s); err != nil {
		return err
	}

	// 解析自定義時(shí)間格式
	parsedTime, err := time.Parse(time.RFC3339, s)
	if err != nil {
		return err
	}

	ct.Time = parsedTime
	return nil
}

func main() {
	// 模擬從HTTP請(qǐng)求中獲取的JSON數(shù)據(jù)
	jsonData := []byte(`{
		"username": "johndoe",
		"email": "john.doe@example.com",
		"last_seen": "2023-04-01T12:34:56Z",
		"active": true
	}`)

	// 創(chuàng)建一個(gè) User 實(shí)例
	var user User

	// 使用 json.Unmarshal 解碼 JSON 數(shù)據(jù)
	if err := json.Unmarshal(jsonData, &user); err != nil {
		log.Fatal("Error unmarshaling JSON:", err)
	}

	// 打印解碼后的信息
	fmt.Printf("Name: %s\n", user.Name)
	fmt.Printf("Email: %s\n", user.Email)
	fmt.Printf("Last Seen: %v\n", user.LastSeen)
	// Active 字段將不會(huì)被解碼，即使JSON中存在
	fmt.Printf("Active: %v\n", user.Active)
	//輸出：
	//Name: johndoe
	//Email: john.doe@example.com
	//	Last Seen: 2023-04-01 12:34:56 +0000 UTC
	//Active: false
}

5、更靈活地使用JSON

使用json.RawMessage

json.RawMessage其實(shí)就是[]byte類型的重定義?？梢赃M(jìn)行強(qiáng)制類型轉(zhuǎn)換。

現(xiàn)在有這么一種場(chǎng)景，結(jié)構(gòu)體中的其中一個(gè)字段的格式是未知的：

type Command struct {
	ID   int
	Cmd  string
	Args *json.RawMessage
}

使用json.RawMessage的話，Args字段在Unmarshal時(shí)不會(huì)被解析，直接將字節(jié)數(shù)據(jù)賦值給Args。我們可以能先解包第一層的JSON數(shù)據(jù)，然后根據(jù)Cmd的值，再確定Args的具體類型進(jìn)行第二次Unmarshal。

這里要注意的是，一定要使用指針類型*json.RawMessage，否則在Args會(huì)被認(rèn)為是[]byte類型，在打包時(shí)會(huì)被打包成base64編碼的字符串。

案例一

package main

import (
	"encoding/json"
	"fmt"
	"log"
)

type Command struct {
	ID   int
	Cmd  string
	Args *json.RawMessage // 未解析的JSON片段
}

func main() {
	//json字節(jié)切片
	jsonData := []byte(`{  
		"ID": 1,  
		"Cmd": "example",  
		"Args": ["arg1", "arg2"]  
	}`)

	var cmd Command
	//解碼/反序列化
	if err := json.Unmarshal(jsonData, &cmd); err != nil {
		log.Fatalf("Error unmarshaling JSON: %v", err)
	}

	fmt.Printf("Command: %+v\n", cmd)
	// 如果需要，可以進(jìn)一步處理cmd.Args字段
	// 例如，將其解析為特定的Go類型
	var args []string
	if err := json.Unmarshal(*cmd.Args, &args); err != nil {
		log.Printf("解析錯(cuò)誤: %v", err)
	} else {
		fmt.Printf("Args: %v\n", args)
	}

    //輸出
    //Command: {ID:1 Cmd:example Args:0xc0000080f0}
    //Args: [arg1 arg2]
}

案例二

package main

import (
	"encoding/json"
	"fmt"
	"log"
)

type Command struct {
	ID   int
	Cmd  string
	Args *json.RawMessage // 未解析的JSON片段
}

// UnmarshalJSON 自定義JSON解碼方法，Command實(shí)現(xiàn)了Unmarshaler接口
func (c *Command) UnmarshalJSON(data []byte) error {
	fmt.Println("--------------使用自定義解碼--------------")
	// 定義一個(gè)輔助結(jié)構(gòu)體，用于解碼除Args外的其他字段
	type alias Command
	var aux struct {
		alias // 嵌入別名類型以獲取其他字段
	}

	// 先解碼除Args外的所有字段
	if err := json.Unmarshal(data, &aux); err != nil {
		return err
	}
	fmt.Printf("Command ID: %+v, Cmd: %+v\n", aux.alias.ID, aux.alias.Cmd)

	// 將別名結(jié)構(gòu)體中的字段復(fù)制到c中
	*c = Command(aux.alias)

	// 檢查JSON中是否有Args字段，并處理它
	var m map[string]json.RawMessage
	if err := json.Unmarshal(data, &m); err != nil {
		// 如果這里出錯(cuò)，可能是因?yàn)镴SON格式不正確，但我們可能仍然想要保留已經(jīng)解析的字段
		// 因此，我們可以只記錄一個(gè)錯(cuò)誤，但不返回它
		log.Printf("Error parsing Args field: %v", err)
	} else {
		// 如果Args字段存在，將其賦值給c.Args
		if rawArgs, ok := m["Args"]; ok {
			c.Args = &rawArgs // 注意這里我們?nèi)×藃awArgs的地址

			var args []string
			if err := json.Unmarshal(*c.Args, &args); err != nil {
				log.Printf("Error parsing Args contents: %v", err)
			} else {
				fmt.Printf("Args: %v\n", args)
			}
		}
	}

	// 如果沒有錯(cuò)誤，返回nil
	return nil
}

func main() {
	//json字節(jié)切片
	jsonData := []byte(`{  
		"ID": 1,  
		"Cmd": "example",  
		"Args": ["arg1", "arg2"]  
	}`)

	var cmd Command
	//解碼/反序列化
	if err := json.Unmarshal(jsonData, &cmd); err != nil {
		log.Fatalf("Error unmarshaling JSON: %v", err)
	}
}

案例三

package main

import (
	"encoding/json"
	"fmt"
	"log"
)

type Command struct {
	ID   int
	Cmd  string
	Args *json.RawMessage // 未解析的JSON片段
}

// UnmarshalJSON 自定義JSON解碼方法，Command實(shí)現(xiàn)了Unmarshaler接口
func (c *Command) UnmarshalJSON(data []byte) error {
	fmt.Println("--------------使用自定義解碼--------------")
	// 檢查JSON中是否有Args字段，并處理它
	var m map[string]json.RawMessage
	if err := json.Unmarshal(data, &m); err != nil {
		// 如果這里出錯(cuò)，可能是因?yàn)镴SON格式不正確，但我們可能仍然想要保留已經(jīng)解析的字段
		// 因此，我們可以只記錄一個(gè)錯(cuò)誤，但不返回它
		log.Printf("Error parsing Args field: %v", err)
	} else {
		// 如果Args字段存在，將其賦值給c.Args
		if rawArgs, ok := m["Args"]; ok {
			c.Args = &rawArgs // 注意這里我們?nèi)×藃awArgs的地址

			var args []string
			if err := json.Unmarshal(*c.Args, &args); err != nil {
				log.Printf("Error parsing Args contents: %v", err)
			} else {
				fmt.Printf("Args: %v\n", args)
			}
		}
	}

	// 如果沒有錯(cuò)誤，返回nil
	return nil
}

func main() {
	//json字節(jié)切片
	jsonData := []byte(`{  
		"ID": 1,  
		"Cmd": "example",  
		"Args": ["arg1", "arg2"]  
	}`)

	var cmd Command
	//解碼/反序列化
	if err := json.Unmarshal(jsonData, &cmd); err != nil {
		log.Fatalf("Error unmarshaling JSON: %v", err)
	}
}

調(diào)用的json.Unmarshal，并不是調(diào)用json.Unmarshaler，為什么會(huì)調(diào)用UnmarshalJSON

調(diào)用 json.Unmarshal 函數(shù)時(shí)，您并沒有直接調(diào)用 json.Unmarshaler 接口的方法。但是，json.Unmarshal 函數(shù)在內(nèi)部會(huì)檢查目標(biāo)類型是否實(shí)現(xiàn)了 json.Unmarshaler 接口。如果實(shí)現(xiàn)了該接口，json.Unmarshal 就會(huì)使用您為該類型定義的 UnmarshalJSON 方法來(lái)解碼 JSON 數(shù)據(jù)。

這是 json.Unmarshal 函數(shù)內(nèi)部邏輯的一部分，用于確定如何解碼 JSON 數(shù)據(jù)。具體步驟如下：

json.Unmarshal 接收一個(gè)字節(jié)切片（包含 JSON 數(shù)據(jù)）和一個(gè)目標(biāo)值的指針。
它首先會(huì)檢查目標(biāo)值的類型是否實(shí)現(xiàn)了 json.Unmarshaler 接口。
如果實(shí)現(xiàn)了 json.Unmarshaler 接口，json.Unmarshal 就會(huì)調(diào)用該類型的 UnmarshalJSON 方法，并將 JSON 數(shù)據(jù)的字節(jié)切片作為參數(shù)傳遞給它。
如果目標(biāo)值沒有實(shí)現(xiàn) json.Unmarshaler 接口，json.Unmarshal 就會(huì)使用默認(rèn)的解碼邏輯來(lái)填充目標(biāo)值的字段。

這種機(jī)制使得開發(fā)者能夠靈活地控制 JSON 數(shù)據(jù)到 Go 結(jié)構(gòu)體之間的轉(zhuǎn)換過程。通過實(shí)現(xiàn) json.Unmarshaler 接口，您可以：

處理 JSON 數(shù)據(jù)中不存在的字段。
自定義字段名稱的映射規(guī)則。
處理 JSON 數(shù)據(jù)中的嵌套對(duì)象或數(shù)組。
執(zhí)行額外的驗(yàn)證或數(shù)據(jù)處理邏輯。

以下是簡(jiǎn)單的示例，展示了如何為一個(gè)類型實(shí)現(xiàn) json.Unmarshaler 接口

處理 JSON 數(shù)據(jù)中不存在的字段

假設(shè)我們有一個(gè)結(jié)構(gòu)體，它能夠處理JSON中可能缺失的字段，并且為這些字段提供默認(rèn)值。

在這個(gè)例子中，Age 字段在JSON中不存在，因此它將被賦予其類型的零值（對(duì)于int類型是0）。

package main

import (
	"encoding/json"
	"fmt"
	"log"
)

type User struct {
	Name  string `json:"name"`
	Age   int    `json:"age"`
	Email string `json:"email,omitempty"`
}

func main() {
	var user User
	// JSON 中沒有 "age" 字段，將使用 Age 的零值 0
	jsonData := []byte(`{"name": "John", "email": "john@example.com"}`)
	if err := json.Unmarshal(jsonData, &user); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Name: %s, Age: %d, Email: %s\n", user.Name, user.Age, user.Email)
	//Name: John, Age: 0, Email: john@example.com
}

自定義字段名稱的映射規(guī)則

使用結(jié)構(gòu)體標(biāo)簽中的json鍵來(lái)指定JSON字段名。

在這個(gè)例子中，結(jié)構(gòu)體的字段名和JSON字段名不匹配，我們通過在結(jié)構(gòu)體標(biāo)簽中指定json來(lái)實(shí)現(xiàn)映射。

package main

import (
	"encoding/json"
	"fmt"
	"log"
)

type User struct {
	Username string `json:"user_name"`
	Password string `json:"pass"`
}

func main() {
	var user User
	jsonData := []byte(`{"user_name": "johndoe", "pass": "secret"}`)
	if err := json.Unmarshal(jsonData, &user); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Username: %s, Password: %s\n", user.Username, user.Password)
	//Username: johndoe, Password: secret
}

處理 JSON 數(shù)據(jù)中的嵌套對(duì)象或數(shù)組

解碼一個(gè)包含嵌套結(jié)構(gòu)體的JSON數(shù)據(jù)。

在這個(gè)例子中，Address 是一個(gè)嵌套在 User 結(jié)構(gòu)體中的對(duì)象。

package main

import (
	"encoding/json"
	"fmt"
	"log"
)

type Address struct {
	City    string `json:"city"`
	Country string `json:"country"`
}

type User struct {
	Name    string  `json:"name"`
	Address Address `json:"address"` // 嵌套對(duì)象
}

func main() {
	var user User
	jsonData := []byte(`{"name": "Jane", "address": {"city": "New York", "country": "USA"}}`)
	if err := json.Unmarshal(jsonData, &user); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Name: %s, Lives in %s, %s\n", user.Name, user.Address.City, user.Address.Country)
	//Name: Jane, Lives in New York, USA
}

執(zhí)行額外的驗(yàn)證或數(shù)據(jù)處理邏輯

在UnmarshalJSON方法中添加額外的驗(yàn)證邏輯。

在這個(gè)例子中，我們?yōu)?code>User類型實(shí)現(xiàn)了自定義的UnmarshalJSON方法。在解碼過程中，如果Age字段的值是負(fù)數(shù)，將返回一個(gè)錯(cuò)誤，這是一個(gè)額外的驗(yàn)證邏輯。

package main

import (
	"encoding/json"
	"fmt"
	"log"
)

type User struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

func (u *User) UnmarshalJSON(data []byte) error {
	type Alias User                         // 影子類型，避免遞歸調(diào)用 UnmarshalJSON
	aux := &Alias{Name: u.Name, Age: u.Age} // 使用輔助結(jié)構(gòu)體來(lái)解耦
	if err := json.Unmarshal(data, aux); err != nil {
		return err
	}
	*u = User(*aux) // 將解耦的結(jié)構(gòu)體賦值給當(dāng)前結(jié)構(gòu)體
	if u.Age < 0 {  //年齡不能為負(fù)數(shù)
		return fmt.Errorf("age cannot be negative")
	}
	return nil
}

func main() {
	var user User
	jsonData := []byte(`{"name": "Alice", "age": -5}`)
	if err := json.Unmarshal(jsonData, &user); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Name: %s, Age: %d\n", user.Name, user.Age)
}

在上面的示例中，User類型實(shí)現(xiàn)了 json.Unmarshaler 接口的 UnmarshalJSON 方法，使得 json.Unmarshal 函數(shù)在解碼 JSON 數(shù)據(jù)時(shí)會(huì)調(diào)用這個(gè)方法，而不是使用默認(rèn)的解碼邏輯。這允許我們自定義解碼邏輯，例如只接受特定格式的 JSON 數(shù)據(jù)。

使用interface{}

interface{}類型在Unmarshal時(shí)，會(huì)自動(dòng)將JSON轉(zhuǎn)換為對(duì)應(yīng)的數(shù)據(jù)類型：

JSON的boolean 轉(zhuǎn)換為bool
JSON的數(shù)值轉(zhuǎn)換為float64
JSON的字符串轉(zhuǎn)換為string
JSON的Array 轉(zhuǎn)換為[]interface{}
JSON的Object 轉(zhuǎn)換為map[string]interface{}
JSON的null 轉(zhuǎn)換為nil

需要注意的有兩個(gè)。一個(gè)是所有的JSON數(shù)值自動(dòng)轉(zhuǎn)換為float64類型，使用時(shí)需要再手動(dòng)轉(zhuǎn)換為需要的int，int64等類型。第二個(gè)是JSON的object自動(dòng)轉(zhuǎn)換為map[string]interface{}類型，訪問時(shí)直接用JSON ``Object的字段名作為key進(jìn)行訪問。再不知道JSON數(shù)據(jù)的格式時(shí)，可以使用interface{}。