Go處理json數(shù)據(jù)方法詳解(Marshal,UnMarshal)
json數(shù)據(jù)格式
如果沒操作過json數(shù)據(jù)，建議先看下上面的文章，有助于理解本文后面的內(nèi)容。
Go json包
Marshal()：Go數(shù)據(jù)對象 -> json數(shù)據(jù)
UnMarshal()：Json數(shù)據(jù) -> Go數(shù)據(jù)對象
func Marshal(v interface{}) ([]byte, error)
func Unmarshal(data []byte, v interface{}) error
構(gòu)建json數(shù)據(jù)
Marshal()和MarshalIndent()函數(shù)可以將數(shù)據(jù)封裝成json數(shù)據(jù)。
- struct、slice、array、map都可以轉(zhuǎn)換成json
- struct轉(zhuǎn)換成json的時(shí)候，只有字段首字母大寫的才會(huì)被轉(zhuǎn)換
- map轉(zhuǎn)換的時(shí)候，key必須為string
- 封裝的時(shí)候，如果是指針，會(huì)追蹤指針指向的對象進(jìn)行封裝
例如：
有一個(gè)struct結(jié)構(gòu)：
type Post struct {
Id int
Content string
Author string
}
這個(gè)結(jié)構(gòu)表示博客文章類型，有文章ID，文章內(nèi)容，文章的提交作者。這沒什么可說的，唯一需要指明的是：它是一個(gè)struct，struct可以封裝(編碼)成JSON數(shù)據(jù)。
要將這段struct數(shù)據(jù)轉(zhuǎn)換成json，只需使用Marshal()即可。如下：
post := &Post{1, "Hello World", "userA"}
b, err := json.Marshal(post)
if err != nil {
fmt.Println(nil)
}
Marshal()返回的是一個(gè)[]byte類型，現(xiàn)在變量b就已經(jīng)存儲了一段[]byte類型的json數(shù)據(jù)，可以輸出它：
fmt.Println(string(b))
結(jié)果：
{"Id":1,"Content":"Hello World","Author":"userA"}
可以在封裝成json的時(shí)候進(jìn)行"美化"，使用MarshalIndent()即可自動(dòng)添加前綴(前綴字符串一般設(shè)置為空)和縮進(jìn)：
c,err := json.MarshalIndent(post,"","\t")
if err != nil {
fmt.Println(nil)
}
fmt.Println(string(c))
結(jié)果：
{
"Id": 1,
"Content": "Hello World",
"Author": "userA"
}
除了struct，array、slice、map結(jié)構(gòu)都能解析成json，但是map解析成json的時(shí)候，key必須只能是string，這是json語法要求的。
例如：
// slice -> json
s := []string{"a", "b", "c"}
d, _ := json.MarshalIndent(s, "", "\t")
fmt.Println(string(d))
// map -> json
m := map[string]string{
"a":"aa",
"b":"bb",
"c":"cc",
}
e,_ := json.MarshalIndent(m,"","\t")
fmt.Println(string(e))
返回結(jié)果：
[
"a",
"b",
"c"
]
{
"a": "aa",
"b": "bb",
"c": "cc"
}
使用struct tag輔助構(gòu)建json
struct能被轉(zhuǎn)換的字段都是首字母大寫的字段，但如果想要在json中使用小寫字母開頭的key，可以使用struct的tag來輔助反射。
例如，Post結(jié)構(gòu)增加一個(gè)首字母小寫的字段createAt。
type Post struct {
Id int `json:"ID"`
Content string `json:"content"`
Author string `json:"author"`
Label []string `json:"label"`
}
postp := &Post{
2,
"Hello World",
"userB",
[]string{"linux", "shell"},
}
p, _ := json.MarshalIndent(postp, "", "\t")
fmt.Println(string(p))
結(jié)果：
{
"ID": 2,
"content": "Hello World",
"author": "userB",
"label": [
"linux",
"shell"
]
}
使用struct tag的時(shí)候，幾個(gè)注意點(diǎn)：
- tag中標(biāo)識的名稱將稱為json數(shù)據(jù)中key的值
- tag可以設(shè)置為
`json:"-"`來表示本字段不轉(zhuǎn)換為json數(shù)據(jù)，即使這個(gè)字段名首字母大寫- 如果想要json key的名稱為字符"-"，則可以特殊處理
`json:"-,"`，也就是加上一個(gè)逗號
- 如果想要json key的名稱為字符"-"，則可以特殊處理
- 如果tag中帶有
,omitempty選項(xiàng)，那么如果這個(gè)字段的值為0值，即false、0、""、nil等，這個(gè)字段將不會(huì)轉(zhuǎn)換到j(luò)son中 - 如果字段的類型為bool、string、int類、float類，而tag中又帶有
,string選項(xiàng)，那么這個(gè)字段的值將轉(zhuǎn)換成json字符串
例如：
type Post struct {
Id int `json:"ID,string"`
Content string `json:"content"`
Author string `json:"author"`
Label []string `json:"label,omitempty"`
}
解析json數(shù)據(jù)到struct(結(jié)構(gòu)已知)
json數(shù)據(jù)可以解析到struct或空接口interface{}中(也可以是slice、map等)。理解了上面構(gòu)建json時(shí)的tag規(guī)則，理解解析json就很簡單了。
例如，下面是一段json數(shù)據(jù)：
{
"id": 1,
"content": "hello world",
"author": {
"id": 2,
"name": "userA"
},
"published": true,
"label": [],
"nextPost": null,
"comments": [{
"id": 3,
"content": "good post1",
"author": "userB"
},
{
"id": 4,
"content": "good post2",
"author": "userC"
}
]
}
分析下這段json數(shù)據(jù)：
- 頂層的大括號表示是一個(gè)匿名對象，映射到Go中是一個(gè)struct，假設(shè)這個(gè)struct名稱為Post
- 頂層大括號里的都是Post結(jié)構(gòu)中的字段，這些字段因?yàn)槎际莏son數(shù)據(jù)，所以必須都首字母大寫，同時(shí)設(shè)置tag，tag中的名稱小寫
- 其中author是一個(gè)子對象，映射到Go中是另一個(gè)struct，在Post中這個(gè)字段的名稱為Author，假設(shè)名稱和struct名稱相同，也為Author
- label是一個(gè)數(shù)組，映射到Go中可以是slice，也可以是array，且因?yàn)閖son array為空，所以Go中的slice/array類型不定，比如可以是int，可以是string，也可以是
interface{}，對于這里的示例來說，我們知道標(biāo)簽肯定是string - nextPost是一個(gè)子對象，映射到Go中是一個(gè)struct，但因?yàn)閖son中這個(gè)對象為null，表示這個(gè)對象不存在，所以無法判斷映射到Go中struct的類型。但對此處的示例來說，是沒有下一篇文章，所以它的類型應(yīng)該也是Post類型
- comment是子對象，且是數(shù)組包圍的，映射到Go中，是一個(gè)slice/array，slice/array的類型是一個(gè)struct
分析之后，對應(yīng)地去構(gòu)建struct和struct的tag就很容易了。如下，是根據(jù)上面分析構(gòu)建出來的數(shù)據(jù)結(jié)構(gòu)：
type Post struct {
ID int64 `json:"id"`
Content string `json:"content"`
Author Author `json:"author"`
Published bool `json:"published"`
Label []string `json:"label"`
NextPost *Post `json:"nextPost"`
Comments []*Comment `json:"comments"`
}
type Author struct {
ID int64 `json:"id"`
Name string `json:"name"`
}
type Comment struct {
ID int64 `json:"id"`
Content string `json:"content"`
Author string `json:"author"`
}
注意，前面在介紹構(gòu)建json數(shù)據(jù)的時(shí)候說明過，指針會(huì)進(jìn)行追蹤，所以這里反推出來的struct中使用指針類型是沒問題的。
于是，解析上面的json數(shù)據(jù)到Post類型的對象中，假設(shè)這個(gè)json數(shù)據(jù)存放在a.json文件中。代碼如下：
func main() {
// 打開json文件
fh, err := os.Open("a.json")
if err != nil {
fmt.Println(err)
return
}
defer fh.Close()
// 讀取json文件，保存到j(luò)sonData中
jsonData, err := ioutil.ReadAll(fh)
if err != nil {
fmt.Println(err)
return
}
var post Post
// 解析json數(shù)據(jù)到post中
err = json.Unmarshal(jsonData, &post)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(post)
}
輸出結(jié)果：
{1 hello world {2 userA} true [] <nil> [0xc042072300 0xc0420723c0]}
也許你已經(jīng)感受到了，從json數(shù)據(jù)反推算struct到底有多復(fù)雜，雖然邏輯不難，但如果數(shù)據(jù)復(fù)雜一點(diǎn)，這是件非常惡心的事情。所以，使用別人寫好的工具來自動(dòng)轉(zhuǎn)換吧。本文后面有推薦json到數(shù)據(jù)結(jié)構(gòu)的自動(dòng)轉(zhuǎn)換工具。
解析json到interface(結(jié)構(gòu)未知)
上面是已知json數(shù)據(jù)結(jié)構(gòu)的解析方式，如果json結(jié)構(gòu)是未知的或者結(jié)構(gòu)可能會(huì)發(fā)生改變的情況，則解析到struct是不合理的。這時(shí)可以解析到空接口interface{}或map[string]interface{}類型上，這兩種類型的結(jié)果是完全一致的。
解析到interface{}上時(shí)，Go類型和JSON類型的對應(yīng)關(guān)系如下
JSON類型 Go類型
---------------------------------------------
JSON objects <--> map[string]interface{}
JSON arrays <--> []interface{}
JSON booleans <--> bool
JSON numbers <--> float64
JSON strings <--> string
JSON null <--> nil
例如：
func main() {
// 讀取json文件
fh, err := os.Open("a.json")
if err != nil {
fmt.Println(err)
return
}
defer fh.Close()
jsonData, err := ioutil.ReadAll(fh)
if err != nil {
fmt.Println(err)
return
}
// 定義空接口接收解析后的json數(shù)據(jù)
var unknown interface{}
// 或：map[string]interface{} 結(jié)果是完全一樣的
err = json.Unmarshal(jsonData, &unknown)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(unknown)
}
輸出結(jié)果：
map[nextPost:<nil> comments:[map[id:3 content:good post1 author:userB] map[id:4 content:good post2 author:userC]] id:1 content:hello world author:map[id:2 name:userA] published:true label:[]]
上面將輸出map結(jié)構(gòu)。這是顯然的，因?yàn)轭愋蛯?yīng)關(guān)系中已經(jīng)說明了，json object解析到Go interface的時(shí)候，對應(yīng)的是map結(jié)構(gòu)。如果將上面輸出的結(jié)構(gòu)進(jìn)行一下格式化，得到的將是類似下面的結(jié)構(gòu)：
map[
nextPost:<nil>
comments:[
map[
id:3
content:good post1
author:userB
]
map[
id:4
content:good post2
author:userC
]
]
id:1
content:hello world
author:map[
id:2
name:userA
]
published:true
label:[]
]
現(xiàn)在，可以從這個(gè)map中去判斷類型、取得對應(yīng)的值。但是如何判斷類型？可以使用類型斷言：
func main() {
// 讀取json數(shù)據(jù)
fh, err := os.Open("a.json")
if err != nil {
fmt.Println(err)
return
}
defer fh.Close()
jsonData, err := ioutil.ReadAll(fh)
if err != nil {
fmt.Println(err)
return
}
// 解析json數(shù)據(jù)到interface{}
var unknown interface{}
err = json.Unmarshal(jsonData, &unknown)
if err != nil {
fmt.Println(err)
return
}
// 進(jìn)行斷言，并switch匹配
m := unknown.(map[string]interface{})
for k, v := range m {
switch vv := v.(type) {
case string:
fmt.Println(k, "type: string\nvalue: ", vv)
fmt.Println("------------------")
case float64:
fmt.Println(k, "type: float64\nvalue: ", vv)
fmt.Println("------------------")
case bool:
fmt.Println(k, "type: bool\nvalue: ", vv)
fmt.Println("------------------")
case map[string]interface{}:
fmt.Println(k, "type: map[string]interface{}\nvalue: ", vv)
for i, j := range vv {
fmt.Println(i,": ",j)
}
fmt.Println("------------------")
case []interface{}:
fmt.Println(k, "type: []interface{}\nvalue: ", vv)
for key, value := range vv {
fmt.Println(key, ": ", value)
}
fmt.Println("------------------")
default:
fmt.Println(k, "type: nil\nvalue: ", vv)
fmt.Println("------------------")
}
}
}
結(jié)果如下：
comments type: []interface{}
value: [map[id:3 content:good post1 author:userB] map[author:userC id:4 content:good post2]]
0 : map[id:3 content:good post1 author:userB]
1 : map[id:4 content:good post2 author:userC]
------------------
id type: float64
value: 1
------------------
content type: string
value: hello world
------------------
author type: map[string]interface{}
value: map[id:2 name:userA]
name : userA
id : 2
------------------
published type: bool
value: true
------------------
label type: []interface{}
value: []
------------------
nextPost type: nil
value: <nil>
------------------
可見，從interface中解析非常復(fù)雜，而且可能因?yàn)榍短捉Y(jié)構(gòu)而導(dǎo)致無法正確迭代遍歷。這時(shí)候，可以使用第三方包simplejson，見后文。
解析、創(chuàng)建json流
除了可以直接解析、創(chuàng)建json數(shù)據(jù)，還可以處理流式數(shù)據(jù)。
- type Decoder解碼json到Go數(shù)據(jù)結(jié)構(gòu)
- type Encoder編碼Go數(shù)據(jù)結(jié)構(gòu)到j(luò)son
例如：
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)
}
輸出：
Ed: Knock knock. Sam: Who's there? Ed: Go fmt. Sam: Go fmt who? Ed: Go fmt yourself!
再例如，從標(biāo)準(zhǔn)輸入讀json數(shù)據(jù)，解碼后刪除名為Name的元素，最后重新編碼后輸出到標(biāo)準(zhǔn)輸出。
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)
}
}
}
json轉(zhuǎn)Go數(shù)據(jù)結(jié)構(gòu)工具推薦
quicktype工具，可以輕松地將json文件轉(zhuǎn)換成各種語言對應(yīng)的數(shù)據(jù)結(jié)構(gòu)。
在vscode中有相關(guān)插件
- 先在命令面板中輸入"set quicktype target language"選擇要將json轉(zhuǎn)換成什么語言的數(shù)據(jù)結(jié)構(gòu)(比如Go)
- 再輸入"open quicktype for json"就可以將當(dāng)前json文件轉(zhuǎn)換對應(yīng)的數(shù)據(jù)結(jié)構(gòu)(比如struct)
轉(zhuǎn)換后只需按實(shí)際的需求稍微修改一部分類型即可。比如為json頂級匿名對象對應(yīng)的struct設(shè)定名稱，還有一些無法轉(zhuǎn)換成struct時(shí)因?yàn)榕袛鄶?shù)據(jù)類型而使用的interface{}類型也要改一改。
例如，下面是使用quicktype工具對前面示例json數(shù)據(jù)進(jìn)行轉(zhuǎn)換后的數(shù)據(jù)結(jié)構(gòu)：
type A struct {
ID int64 `json:"id"`
Content string `json:"content"`
Author Author `json:"author"`
Published bool `json:"published"`
Label []interface{} `json:"label"`
NextPost interface{} `json:"nextPost"`
Comments []Comment `json:"comments"`
}
type Author struct {
ID int64 `json:"id"`
Name string `json:"name"`
}
type Comment struct {
ID int64 `json:"id"`
Content string `json:"content"`
Author string `json:"author"`
}
其中需要將type A struct的A改成你自己的名稱，將A中的interface{}也改成合理的類型。
更多關(guān)于Go處理json數(shù)據(jù)方法請查看下面的相關(guān)鏈接
相關(guān)文章
這篇文章主要介紹了Go語言中數(shù)組的基本用法演示,包括一個(gè)冒泡排序算法的簡單實(shí)現(xiàn),需要的朋友可以參考下2015-10-10
這篇文章主要為大家介紹了GO語言基礎(chǔ)入門的第一個(gè)go程序解讀，下面來帶大家進(jìn)入Go語言世界helloworld的大門吧，有需要的朋友可以借鑒參考下，希望能夠有所幫助2021-11-11
在Go語言編程中,`omitempty`標(biāo)記用于JSON編解碼過程中控制字段是否被包含,當(dāng)結(jié)構(gòu)體字段標(biāo)記為`omitempty`且字段值為空時(shí),該字段不會(huì)出現(xiàn)在生成的JSON中,有助于優(yōu)化JSON結(jié)構(gòu)和減小數(shù)據(jù)體積,通過具體示例解釋了`omitempty`的工作機(jī)制和實(shí)際效果2024-09-09
golang的泛型已經(jīng)出來了一年多了，從提案被接受開始我就在關(guān)注泛型了，好用是好用，但問題也很多，所以本文就來教大家如何在Golang中用好泛型吧2023-07-07
這篇文章主要為大家介紹了Go語言基礎(chǔ)枚舉的用法及示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2021-11-11
這篇文章主要為大家介紹了GO使用Mutex確保并發(fā)程序正確性詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2023-03-03
windows安裝部署go超詳細(xì)實(shí)戰(zhàn)記錄(實(shí)測有用!)
Golang語言在近年來因?yàn)槠涓咝阅堋⒕幾g速度快、開發(fā)成本低等特點(diǎn)逐漸得到大家的青睞,這篇文章主要給大家介紹了關(guān)于windows安裝部署go超詳細(xì)實(shí)戰(zhàn)的相關(guān)資料,需要的朋友可以參考下2023-02-02
Go語言k8s?kubernetes使用leader?election實(shí)現(xiàn)選舉
這篇文章主要為大家介紹了Go語言?k8s?kubernetes?使用leader?election選舉，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2022-10-10
一個(gè)簡單的Golang實(shí)現(xiàn)的HTTP Proxy方法
今天小編就為大家分享一篇一個(gè)簡單的Golang實(shí)現(xiàn)的HTTP Proxy方法，具有很好的參考價(jià)值，希望對大家有所幫助。一起跟隨小編過來看看吧2019-08-08
如何使用Go語言實(shí)現(xiàn)遠(yuǎn)程執(zhí)行命令
遠(yuǎn)程執(zhí)行命令最常用的方法就是利用SSH協(xié)議,將命令發(fā)送到遠(yuǎn)程機(jī)器上執(zhí)行,并獲取返回結(jié)果。本文將介紹如何使用Go語言實(shí)現(xiàn)遠(yuǎn)程執(zhí)行命令。下面一起來看看。2016-08-08