go-simplejson文檔學習

https://godoc.org/github.com/bitly/go-simplejson

導入方式：

import "github.com/bitly/go-simplejson"

用來解析未知結構的JSON的包

首先要使用下面的語句先下載該包才能使用：

go get "github.com/bitly/go-simplejson"

 

func Version

func Version() string

返回當前操做的go-simplejson版本

package main 
import(
    "fmt"
    "github.com/bitly/go-simplejson"
)

func main() {
    fmt.Println(simplejson.Version()) //0.5.0
}

 

type Json

type Json struct {
    // 包含過濾和未支持字段
}

func NewFromReader

func NewFromReader(r io.Reader) (*Json, error)

NewFromReader經過從io.Reader取值，而後解碼返回一個*Json

func (*Json) Array

func (j *Json) Array() ([]interface{}, error)

Array類型斷言成 `array`

func (*Json) MustArray

func (j *Json) MustArray(args ...[]interface{}) []interface{}

MustArray保證返回一個' []interface{} '(默認爲可選)，當你想以一種簡潔的方式對數組值進行交互時頗有用:

for i, v := range js.Get("results").MustArray() {
    fmt.Println(i, v)
}

func (*Json) Get

func (j *Json) Get(key string) *Json

Get返回一個指向一個新的「Json」對象的指針，該對象在其「map」表示法中的「key」表示形式對連接操做(用於遍歷嵌套Json)頗有用，即多個Get連用表示嵌套獲取值:

js.Get("top_level").Get("dict").Get("value").Int()

func (*Json) GetIndex

func (j *Json) GetIndex(index int) *Json

GetIndex returns a pointer to a new `Json` object for `index` in its `array` representation

this is the analog to Get when accessing elements of a json array instead of a json object:

GetIndex在它的「數組array」表示法中爲「index」返回一個指向新的「Json」對象的指針
這是在訪問json數組而不是json對象的元素時獲得的模擬:

js.Get("top_level").Get("array").GetIndex(1).Get("key").Int()

其實就是獲得數組中索引爲index的值

func (*Json) Int

func (j *Json) Int() (int, error)

Int()強制轉換值爲int類型

func (*Json) MustInt

func (j *Json) MustInt(args ...int) int

MustInt保證返回一個'int'值（默認爲可選）,當你想要顯示地在一個單一值返回上下文中獲得一個'int'，這個函數是十分有用的:

myFunc(js.Get("param1").MustInt(), js.Get("optional_param").MustInt(5150))

即便不存在"optional_param"這個字段，也可以保證返回一個int類型的5150

func (*Json) Map

func (j *Json) Map() (map[string]interface{}, error)

Map 類型斷言爲 `map`

func (*Json) MustMap

func (j *Json) MustMap(args ...map[string]interface{}) map[string]interface{}

MustMap保證返回一個`map[string]interface{}` (默認爲可選)

當你但願以簡潔的方式對映射值進行交互時它頗有用:

for k, v := range js.Get("dictionary").MustMap() {
    fmt.Println(k, v)
}

func (*Json) Int64

func (j *Json) Int64() (int64, error)

強制轉換爲int64

func (*Json) MustInt64

func (j *Json) MustInt64(args ...int64) int64

MustInt64 保證返回爲`int64` (默認爲可選)

當你明確想要在一個值返回上下文中有一個' int64 '時，它是很是有用的:

myFunc(js.Get("param1").MustInt64(), js.Get("optional_param").MustInt64(5150))

即便不存在"optional_param"這個字段，也可以保證返回一個int64類型的5150

舉例：

package main 
import(
    "fmt"
    "github.com/bitly/go-simplejson"
    "bytes"
    "log"
)

func main() {
    buf := bytes.NewBuffer([]byte(`{
        "test": {
            "array": [1, "2", 3],
            "arraywithsubs": [
                {"subkeyone": 1},
                {"subkeytwo": 2, "subkeythree": 3}
            ],
            "bignum": 8000000000
        }
    }`))
    js, err := simplejson.NewFromReader(buf)
    if err != nil || js == nil{
        log.Fatal("something wrong when call NewFromReader")
    }
    fmt.Println(js) //&{map[test:map[array:[1 2 3] arraywithsubs:[map[subkeyone:1] map[subkeytwo:2 subkeythree:3]] bignum:8000000000]]}


    arr, err := js.Get("test").Get("array").Array()
    if err != nil || arr == nil{
        log.Fatal("something wrong when call Get and Array")
    }
    fmt.Println(arr) //[1 2 3]
    
    //使用下面的Must類方法就不用判斷而err了
    fmt.Println(js.Get("test").Get("array").MustArray()) //[1 2 3]

    fmt.Println(js.Get("test").Get("arraywithsubs").GetIndex(0).MustMap()) //map[subkeyone:1]

    fmt.Println(js.Get("test").Get("bignum").MustInt64()) //8000000000
}

 

func NewJson

func NewJson(body []byte) (*Json, error)

NewJson在解封body後返回一個指向新`Json`對象的指針

若是上面的例子不使用NewFromReader，而是使用NewJson將寫成：

package main 
import(
    "fmt"
    "github.com/bitly/go-simplejson"
    "log"
)

func main() {
    js, err := simplejson.NewJson([]byte(`{
        "test": {
            "array": [1, "2", 3],
            "arraywithsubs": [
                {"subkeyone": 1},
                {"subkeytwo": 2, "subkeythree": 3}
            ],
            "bignum": 8000000000
        }
    }`))

    if err != nil || js == nil{
        log.Fatal("something wrong when call NewFromReader")
    }
    fmt.Println(js) //&{map[test:map[array:[1 2 3] arraywithsubs:[map[subkeyone:1] map[subkeytwo:2 subkeythree:3]] bignum:8000000000]]}


    arr, err := js.Get("test").Get("array").Array()
    if err != nil || arr == nil{
        log.Fatal("something wrong when call Get and Array")
    }
    fmt.Println(arr) //[1 2 3]
    
    //使用下面的Must類方法就不用判斷而err了
    fmt.Println(js.Get("test").Get("array").MustArray()) //[1 2 3]

    fmt.Println(js.Get("test").Get("arraywithsubs").GetIndex(0).MustMap()) //map[subkeyone:1]

    fmt.Println(js.Get("test").Get("bignum").MustInt64()) //8000000000
}

 

func (*Json) GetPath

func (j *Json) GetPath(branch ...string) *Json

GetPath搜索分支指定的項，而不須要使用Get()的深度搜索。

js.GetPath("top_level", "dict")

 直接指定先查找字段"top_level"，而後再在其子字段中查找"dict"，而不用深度搜索

func (*Json) CheckGet

func (j *Json) CheckGet(key string) (*Json, bool)

CheckGet返回一個指向新「Json」對象的指針和一個標識成功或失敗的「bool」
當成功很重要時，鏈式操做很是有用:

if data, ok := js.Get("top_level").CheckGet("inner"); ok {
    log.Println(data)
}

其實就是用來查看該嵌套層中是否有key爲"inner"的字段

func (*Json) Del

func (j *Json) Del(key string)

Del modifies `Json` map by deleting `key` if it is present.

若是存在則經過刪除key來修改Json映射

func (*Json) Set

func (j *Json) Set(key string, val interface{})

Set經過「鍵」和「值」修改「Json」映射，這對於輕鬆更改「Json」對象中的單個鍵/值很是有用。

func (*Json) SetPath

func (j *Json) SetPath(branch []string, val interface{})

SetPath修改Json對象，遞歸地檢查/建立提供路徑的映射鍵，最後寫入值val

func (*Json) String

func (j *Json) String() (string, error)

類型斷言爲`string`

func (*Json) MustString

func (j *Json) MustString(args ...string) string

MustString保證返回一個「字符串」(默認爲可選)
當你明確地想要一個「字符串」在一個值返回上下文中:

myFunc(js.Get("param1").MustString(), js.Get("optional_param").MustString("my_default"))

func (*Json) StringArray

func (j *Json) StringArray() ([]string, error)

StringArray類型斷言爲 `string`類型的數組

舉例：

package main 
import(
    "fmt"
    "github.com/bitly/go-simplejson"
    "log"
)

func main() {
    js, err := simplejson.NewJson([]byte(`{
        "test": {
            "string_array": ["asdf", "ghjk", "zxcv"],
            "string_array_null": ["abc", null, "efg"],
            "array": [1, "2", 3],
            "arraywithsubs": [{"subkeyone": 1},
            {"subkeytwo": 2, "subkeythree": 3}],
            "int": 10,
            "float": 5.150,
            "string": "simplejson",
            "bool": true,
            "sub_obj": {"a": 1}
        }
    }`))
    if err != nil {
        log.Fatal(err)
    }
    _, ok := js.CheckGet("test") //true ,有該字段
    fmt.Println(ok)
    missJson, ok := js.CheckGet("missing_key") 
    fmt.Println(ok)//false，沒有該字段
    fmt.Println(missJson) //<nil>

    fmt.Println(js.Get("test").Get("string").MustString()) //simplejson
    fmt.Println(js.Get("test").Get("missing_array").MustArray([]interface{}{"1", 2, "3"})) //[1 2 3]

    msa := js.Get("test").Get("string_array").MustStringArray() 
    for _,v := range msa{
        fmt.Println(v)
    }
    //返回：
    //asdf
    //ghjk
    //zxcv

    gp, _ := js.GetPath("test", "string").String()
    fmt.Println(gp) //simplejson

    js.Set("test2", "setTest")
    fmt.Println(js.Get("test2").MustString()) //setTest
    js.Del("test2")
    fmt.Println(js.Get("test2").MustString()) //爲空

    s := make([]string, 2)
    s[0] = "test2"
    s[1] = "name"
    js.SetPath(s, "testSetPath")
    gp, _ = js.GetPath("test2", "name").String()
    fmt.Println(gp) //testSetPath
}

 

func (*Json) MarshalJSON

func (j *Json) MarshalJSON() ([]byte, error)

實現json.Marshaler接口

做用其實就是將JSON類型的值轉成[]byte

func (*Json) UnmarshalJSON

func (j *Json) UnmarshalJSON(p []byte) error

實現json.Unmarshaler接口

做用其實就是將[]byte類型的值轉成JSON類型

舉例：

package main 
import(
    "fmt"
    "github.com/bitly/go-simplejson"
    "log"
)

func main() {
    js, err := simplejson.NewJson([]byte(`{}`))
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(js) //&{map[]}

    err = js.UnmarshalJSON([]byte(`{
        "test": {
            "string_array": ["asdf", "ghjk", "zxcv"],
            "int": 10,
            "float": 5.150,
            "string": "simplejson",
            "bool": true,
            "sub_obj": {"a": 1}
        }
    }`))
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(js) //&{map[test:map[string:simplejson bool:true sub_obj:map[a:1] string_array:[asdf ghjk zxcv] int:10 float:5.150]]}

    unjs, err := js.MarshalJSON()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("[]byte json is :%s\n", unjs) 
    //[]byte json is :{"test":{"bool":true,"float":5.150,"int":10,"string":"simplejson","string_array":["asdf","ghjk","zxcv"],"sub_obj":{"a":1}}}
}

 

其餘函數還有：

func New

func New() *Json

New返回一個新建的指針，是空的Json對象

func (*Json) Bool

func (j *Json) Bool() (bool, error)

Bool類型斷言爲`bool`

func (*Json) MustBool

func (j *Json) MustBool(args ...bool) bool

MustBool保證返回一個「bool」(帶有可選默認值)
當你明確地想要一個「bool」在一個值返回上下文中:

myFunc(js.Get("param1").MustBool(), js.Get("optional_param").MustBool(true))

func (*Json) Bytes

func (j *Json) Bytes() ([]byte, error)

Bytes類型斷言爲`[]byte`

func (*Json) Encode

func (j *Json) Encode() ([]byte, error)

Encode返回其編碼數據爲 `[]byte`

func (*Json) EncodePretty

func (j *Json) EncodePretty() ([]byte, error)

EncodePretty返回其編碼數據爲帶有縮進的 `[]byte`

func (*Json) Float64

func (j *Json) Float64() (float64, error)

Float64強制轉換爲float64

func (*Json) MustFloat64

func (j *Json) MustFloat64(args ...float64) float64

MustFloat64保證返回一個「float64」(可選默認值)
當您明確但願在一個值返回上下文中使用「float64」時，這將很是有用:

myFunc(js.Get("param1").MustFloat64(), js.Get("optional_param").MustFloat64(5.150))

func (*Json) Interface

func (j *Json) Interface() interface{}

Interface返回底層數據

func (*Json) Uint64

func (j *Json) Uint64() (uint64, error)

Uint64強制轉換爲uint64

func (*Json) MustUint64

func (j *Json) MustUint64(args ...uint64) uint64

MustUInt64保證返回一個「uint64」(默承認選)
當你明確想在一個值返回上下文中有一個' uint64 '

myFunc(js.Get("param1").MustUint64(), js.Get("optional_param").MustUint64(5150))