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))