Go處理json數據

時間  2019-11-06
標籤 處理 json 數據 欄目 JavaScript 简体版
原文   原文鏈接

json數據格式

參見json數據格式說明。html

若是沒操做過json數據，建議先看下上面的文章，有助於理解本文後面的內容。linux

Go json包

Marshal()：Go數據對象 -> json數據
UnMarshal()：Json數據 -> Go數據對象shell

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

構建json數據

Marshal()和MarshalIndent()函數能夠將數據封裝成json數據。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數據，能夠輸出它：post

fmt.Println(string(b))

結果：ui

{"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的時候，幾個注意點：

  1. tag中標識的名稱將稱爲json數據中key的值
  2. tag能夠設置爲`json:"-"`來表示本字段不轉換爲json數據，即便這個字段名首字母大寫
    • 若是想要json key的名稱爲字符"-"，則能夠特殊處理`json:"-,"`，也就是加上一個逗號
  3. 若是tag中帶有,omitempty選項，那麼若是這個字段的值爲0值，即false、0、""、nil等，這個字段將不會轉換到json中
  4. 若是字段的類型爲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數據：

  1. 頂層的大括號表示是一個匿名對象，映射到Go中是一個struct，假設這個struct名稱爲Post
  2. 頂層大括號裏的都是Post結構中的字段，這些字段由於都是json數據，因此必須都首字母大寫，同時設置tag，tag中的名稱小寫
  3. 其中author是一個子對象，映射到Go中是另外一個struct，在Post中這個字段的名稱爲Author，假設名稱和struct名稱相同，也爲Author
  4. label是一個數組，映射到Go中能夠是slice，也能夠是array，且由於json array爲空，因此Go中的slice/array類型不定，好比能夠是int，能夠是string，也能夠是interface{}，對於這裏的示例來講，咱們知道標籤確定是string
  5. nextPost是一個子對象，映射到Go中是一個struct，但由於json中這個對象爲null，表示這個對象不存在，因此沒法判斷映射到Go中struct的類型。但對此處的示例來講，是沒有下一篇文章，因此它的類型應該也是Post類型
  6. 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文件轉換成各類語言對應的數據結構。

地址：https://quicktype.io

在vscode中有相關插件

  1. 先在命令面板中輸入"set quicktype target language"選擇要將json轉換成什麼語言的數據結構(好比Go)
  2. 再輸入"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{}也改爲合理的類型。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程