json數據格式 參見 "json數據格式說明" 。 如果沒操作過json數據,建議先看下上面的文章,有助於理解本文後面的內容。 Go json包 Marshal():Go數據對象 json數據 UnMarshal():Json數據 Go數據對象 構建json數據 Marshal()和Marshal ...
json數據格式
參見json數據格式說明。
如果沒操作過json數據,建議先看下上面的文章,有助於理解本文後面的內容。
Go json包
Marshal():Go數據對象 -> json數據
UnMarshal():Json數據 -> Go數據對象
func Marshal(v interface{}) ([]byte, error)
func Unmarshal(data []byte, v interface{}) error
構建json數據
Marshal()和MarshalIndent()函數可以將數據封裝成json數據。
- struct、slice、array、map都可以轉換成json
- struct轉換成json的時候,只有欄位首字母大寫的才會被轉換
- map轉換的時候,key必須為string
- 封裝的時候,如果是指針,會追蹤指針指向的對象進行封裝
例如:
有一個struct結構:
type Post struct {
Id int
Content string
Author string
}
這個結構表示博客文章類型,有文章ID,文章內容,文章的提交作者。這沒什麼可說的,唯一需要指明的是:它是一個struct,struct可以封裝(編碼)成JSON數據。
要將這段struct數據轉換成json,只需使用Marshal()即可。如下:
post := &Post{1, "Hello World", "userA"}
b, err := json.Marshal(post)
if err != nil {
fmt.Println(nil)
}
Marshal()返回的是一個[]byte
類型,現在變數b就已經存儲了一段[]byte
類型的json數據,可以輸出它:
fmt.Println(string(b))
結果:
{"Id":1,"Content":"Hello World","Author":"userA"}
可以在封裝成json的時候進行"美化",使用MarshalIndent()即可自動添加首碼(首碼字元串一般設置為空)和縮進:
c,err := json.MarshalIndent(post,"","\t")
if err != nil {
fmt.Println(nil)
}
fmt.Println(string(c))
結果:
{
"Id": 1,
"Content": "Hello World",
"Author": "userA"
}
除了struct,array、slice、map結構都能解析成json,但是map解析成json的時候,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))
返回結果:
[
"a",
"b",
"c"
]
{
"a": "aa",
"b": "bb",
"c": "cc"
}
使用struct tag輔助構建json
struct能被轉換的欄位都是首字母大寫的欄位,但如果想要在json中使用小寫字母開頭的key,可以使用struct的tag來輔助反射。
例如,Post結構增加一個首字母小寫的欄位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))
結果:
{
"ID": 2,
"content": "Hello World",
"author": "userB",
"label": [
"linux",
"shell"
]
}
使用struct tag的時候,幾個註意點:
- tag中標識的名稱將稱為json數據中key的值
- tag可以設置為
`json:"-"`
來表示本欄位不轉換為json數據,即使這個欄位名首字母大寫- 如果想要json key的名稱為字元"-",則可以特殊處理
`json:"-,"`
,也就是加上一個逗號
- 如果想要json key的名稱為字元"-",則可以特殊處理
- 如果tag中帶有
,omitempty
選項,那麼如果這個欄位的值為0值,即false、0、""、nil等,這個欄位將不會轉換到json中
- 如果欄位的類型為bool、string、int類、float類,而tag中又帶有
,string
選項,那麼這個欄位的值將轉換成json字元串
例如:
type Post struct {
Id int `json:"ID,string"`
Content string `json:"content"`
Author string `json:"author"`
Label []string `json:"label,omitempty"`
}
解析json數據到struct(結構已知)
json數據可以解析到struct或空介面interface{}
中(也可以是slice、map等)。理解了上面構建json時的tag規則,理解解析json就很簡單了。
例如,下麵是一段json數據:
{
"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數據:
- 頂層的大括弧表示是一個匿名對象,映射到Go中是一個struct,假設這個struct名稱為Post
- 頂層大括弧里的都是Post結構中的欄位,這些欄位因為都是json數據,所以必須都首字母大寫,同時設置tag,tag中的名稱小寫
- 其中author是一個子對象,映射到Go中是另一個struct,在Post中這個欄位的名稱為Author,假設名稱和struct名稱相同,也為Author
- label是一個數組,映射到Go中可以是slice,也可以是array,且因為json array為空,所以Go中的slice/array類型不定,比如可以是int,可以是string,也可以是
interface{}
,對於這裡的示例來說,我們知道標簽肯定是string
- nextPost是一個子對象,映射到Go中是一個struct,但因為json中這個對象為null,表示這個對象不存在,所以無法判斷映射到Go中struct的類型。但對此處的示例來說,是沒有下一篇文章,所以它的類型應該也是Post類型
- comment是子對象,且是數組包圍的,映射到Go中,是一個slice/array,slice/array的類型是一個struct
分析之後,對應地去構建struct和struct的tag就很容易了。如下,是根據上面分析構建出來的數據結構:
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"`
}
註意,前面在介紹構建json數據的時候說明過,指針會進行追蹤,所以這裡反推出來的struct中使用指針類型是沒問題的。
於是,解析上面的json數據到Post類型的對象中,假設這個json數據存放在a.json文件中。代碼如下:
func main() {
// 打開json文件
fh, err := os.Open("a.json")
if err != nil {
fmt.Println(err)
return
}
defer fh.Close()
// 讀取json文件,保存到jsonData中
jsonData, err := ioutil.ReadAll(fh)
if err != nil {
fmt.Println(err)
return
}
var post Post
// 解析json數據到post中
err = json.Unmarshal(jsonData, &post)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(post)
}
輸出結果:
{1 hello world {2 userA} true [] <nil> [0xc042072300 0xc0420723c0]}
也許你已經感受到了,從json數據反推算struct到底有多複雜,雖然邏輯不難,但如果數據複雜一點,這是件非常噁心的事情。所以,使用別人寫好的工具來自動轉換吧。本文後面有推薦json到數據結構的自動轉換工具。
解析json到interface(結構未知)
上面是已知json數據結構的解析方式,如果json結構是未知的或者結構可能會發生改變的情況,則解析到struct是不合理的。這時可以解析到空介面interface{}
或map[string]interface{}
類型上,這兩種類型的結果是完全一致的。
解析到interface{}
上時,Go類型和JSON類型的對應關係如下
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數據
var unknown interface{}
// 或:map[string]interface{} 結果是完全一樣的
err = json.Unmarshal(jsonData, &unknown)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(unknown)
}
輸出結果:
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結構。這是顯然的,因為類型對應關係中已經說明瞭,json object解析到Go interface的時候,對應的是map結構。如果將上面輸出的結構進行一下格式化,得到的將是類似下麵的結構:
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中去判斷類型、取得對應的值。但是如何判斷類型?可以使用類型斷言:
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數據到interface{}
var unknown interface{}
err = json.Unmarshal(jsonData, &unknown)
if err != nil {
fmt.Println(err)
return
}
// 進行斷言,並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("------------------")
}
}
}
結果如下:
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中解析非常複雜,而且可能因為嵌套結構而導致無法正確迭代遍歷。這時候,可以使用第三方包simplejson,見後文。
解析、創建json流
除了可以直接解析、創建json數據,還可以處理流式數據。
- type Decoder解碼json到Go數據結構
- type Encoder編碼Go數據結構到json
例如:
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!
再例如,從標準輸入讀json數據,解碼後刪除名為Name的元素,最後重新編碼後輸出到標準輸出。
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轉Go數據結構工具推薦
quicktype工具,可以輕鬆地將json文件轉換成各種語言對應的數據結構。
在vscode中有相關插件
- 先在命令面板中輸入"set quicktype target language"選擇要將json轉換成什麼語言的數據結構(比如Go)
- 再輸入"open quicktype for json"就可以將當前json文件轉換對應的數據結構(比如struct)
轉換後只需按實際的需求稍微修改一部分類型即可。比如為json頂級匿名對象對應的struct設定名稱,還有一些無法轉換成struct時因為判斷數據類型而使用的interface{}
類型也要改一改。
例如,下麵是使用quicktype工具對前面示例json數據進行轉換後的數據結構:
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{}
也改成合理的類型。