Go處理json數據

来源:https://www.cnblogs.com/f-ck-need-u/archive/2018/12/07/10080793.html
-Advertisement-
Play Games

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的時候,幾個註意點:

  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{}也改成合理的類型。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 享元模式是一種很常用的思想,核心就是共用,剝離事物的內部狀態與外部狀態,本文對享元模式 FlyWeight進行了簡單介紹,並且給出了該模式的意圖,結構,並且介紹了享元模式的兩種應用方式單純享元模式與複合享元模式,並且給出來了Java的示例代碼。享元模式的特點,結構,使用場景,都可以在本文中找到。 ...
  • 在導入一些包的時候出現報錯 1、File->Invalidate Caches/Restart 清除緩存並重啟 idea2、檢查pom文件中的依賴關係是否正確3、maven -> Reimport ...
  • 學習java之前首先在https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html上面下載與自己電腦版本相同的jdk,並且安裝到預設的路徑。 1.配置JAVA_HOME的環境變數:電腦→右鍵 ...
  • 題意 "題目鏈接" Sol 紫色的線段樹板子題??。。。 ...
  • 題目內容: 電腦內部用二進位來表達所有的值。一個十進位的數字,比如18,在一個32位的電腦內部被表達為00000000000000000000000000011000。可以看到,從左邊數過來,在第一個1之前,有27個0。我們把這些0稱作前導的零。 現在,你的任務是寫一個程式,輸入一個整數,輸出在 ...
  • 在Timer模塊中有提到,libuv控制著延遲事件的觸發,那麼必須想辦法精確控制時間。 如果是JS,獲取當前時間可以直接通過Date.now()得到一個時間戳,然後將兩段時間戳相減得到時間差。一般情況下當然沒有問題,但是這個方法並不保險,因為本地電腦時間可以修改。 libuv顯然不會用這麼愚蠢的辦 ...
  • 題目內容: 一個正整數的因數是所有可以整除它的正整數。而一個數如果恰好等於除它本身外的因數之和,這個數就稱為完數。例如6=1+2+3(6的因數是1,2,3)。 現在,你要寫一個程式,讀入兩個正整數n和m(1<=n<m<1000),輸出[n,m]範圍內所有的完數。 提示:可以寫一個函數來判斷某個數是否 ...
  • 題目內容: 每個非素數(合數)都可以寫成幾個素數(也可稱為質數)相乘的形式,這幾個素數就都叫做這個合數的質因數。比如,6可以被分解為2x3,而24可以被分解為2x2x2x3。 現在,你的程式要讀入一個[2,100000]範圍內的整數,然後輸出它的質因數分解式;當讀到的就是素數時,輸出它本身。 輸入格 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發(一):使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說,近來想嘗試開發一款安卓APP,考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP,畢竟是使用Visual Studio開發工具,使用起來也比較的順手,結合微軟官方的教程進行了安卓 ...
  • 前言 QuestPDF 是一個開源 .NET 庫,用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫,它徹底改變了我們生成 PDF 文檔的方 ...
  • 項目地址 項目後端地址: https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址: ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址: http://tree ...
  • 話不多說,直接開乾 一.下載 1.官方鏈接下載: https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe,運行開始下載SQL server; 二. ...
  • 前言 隨著物聯網(IoT)技術的迅猛發展,MQTT(消息隊列遙測傳輸)協議憑藉其輕量級和高效性,已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫,為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog支持多種接收器用於日誌存儲,增強器用於添加屬性,LogContext管理動態屬性,支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項,適用於不同需求。 ...
  • 目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據,爬取信息時需要模擬瀏覽器行為,否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下: 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • 1.前言 什麼是熱更新 游戲或者軟體更新時,無需重新下載客戶端進行安裝,而是在應用程式啟動的情況下,在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR,Xlua,ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles,Addressable, ...
  • 本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺,其實像阿裡雲,騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後,它會送 ...
  • 通過以下方式可以高效,並保證數據同步的可靠性 1.API設計 使用RESTful設計,確保API端點明確,並使用適當的HTTP方法(如POST用於創建,PUT用於更新)。 設計清晰的請求和響應模型,以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證,確保接收到的數據符合預期格 ...