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

即使不存在"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())

即使不存在"optional_param"这个字段,也能够保证返回一个int64类型的5150

举例:

package main
import(
"fmt"
"github.com/bitly/go-simplejson"
"bytes"
"log"
) func main() {
buf := bytes.NewBuffer([]byte(`{
"test": {
"array": [, "", ],
"arraywithsubs": [
{"subkeyone": },
{"subkeytwo": , "subkeythree": }
],
"bignum":
}
}`))
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().MustMap()) //map[subkeyone:1] fmt.Println(js.Get("test").Get("bignum").MustInt64()) //
}

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": [, "", ],
"arraywithsubs": [
{"subkeyone": },
{"subkeytwo": , "subkeythree": }
],
"bignum":
}
}`)) 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().MustMap()) //map[subkeyone:1] fmt.Println(js.Get("test").Get("bignum").MustInt64()) //
}

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": [, "", ],
"arraywithsubs": [{"subkeyone": },
{"subkeytwo": , "subkeythree": }],
"int": ,
"float": 5.150,
"string": "simplejson",
"bool": true,
"sub_obj": {"a": }
}
}`))
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] 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, )
s[] = "test2"
s[] = "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": ,
"float": 5.150,
"string": "simplejson",
"bool": true,
"sub_obj": {"a": }
}
}`))
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())

go-simplejson文档学习的更多相关文章

  1. EasyUI文档学习心得

    概述 jQuery EasyUI 是一组基于jQuery 的UI 插件集合,它可以让开发者在几乎完全不需要CSS以及复杂的JS代码情况下完成美观且功能强大的Web界面. 本文主要说明一些如何利用Eas ...

  2. Spring文档学习

    Spring文档学习 参考Spring Framework Documentation学习 1. IoC 容器 1.1 容器实例化 <beans> <import resource= ...

  3. Cassandra1.2文档学习解读计划——为自己鼓劲

    最近想深入研究一下Cassandra,而Cassandra没有中文文档,仅有的一些参考书都是0.7/0.6版本的.因此有个计划,一边学习文档(地址:http://www.datastax.com/do ...

  4. 《MATLAB从入门到放弃》二维曲线和图形绘制基础(二):使用Help文档学习line、plot、plotyy、subplot、hold绘图函数

    目录: »  plot 最常用的二维曲线绘图函数 >  帮助文档 >  基本使用语法 >  线条的样式.符号和颜色调整 >  图形属性调整 >  使用图形句柄进行设置 » ...

  5. 这可能是最详细的 iOS 学习入门指南(含书目/文档/学习资料)

    1 零基础小白如何进行 iOS 系统学习 首先,学习目标要明确: 其次,有了目标,要培养兴趣,经常给自己一些正面的反馈,比如对自己的进步进行鼓励,在前期小步快走: 再次,学技术最重要的一点就是多动手. ...

  6. 通过程序校验xml文档学习笔记

    校验xml文档,可以通过程序来校验,利用一段js代码即可. 各行代码的含义已经写出,运行这个html文件,检验如下xml代码: 结果如下: 如果xml文档出现错误: 结果如下: 其中,obj.asyn ...

  7. Nodejs v4.x.0API文档学习(2)Assert断言测试模块

    文档参考地址:https://nodejs.org/dist/latest-v4.x/docs/api/ Assert(断言) assert模块提供了一组简单的断言测试方法,可以拥有测试不变量.该模块 ...

  8. Nodejs v4.x.0API文档学习(1)简介

    文档参考地址:https://nodejs.org/dist/latest-v4.x/docs/api/ 简介 下面是用nodejs编写的一个web服务的例子,返回"Hello World& ...

  9. linux 内存-文档学习

    ptmalloc http://www.malloc.de/en/ tcmalloc https://github.com/gperftools/gperftools jcmalloc http:// ...

  10. <文档学习>AirSim/using_car.md Choosing Your Vehicle: Car or Multirotor

    如何在AirSim中使用汽车 默认情况下,AirSim中使用的车型为多转子multirotor. 如果你想使用汽车,那么只需在你的settings.json(https://github.com/Mi ...

随机推荐

  1. .net网站上传图片换电脑不显示

    当不用网站的IP地址访问图片,只用相对路径访问时,在发布网站的时候,将上传图片的目标文件夹,包含在项目中再发布即可.

  2. 使用Nexus2.x为Maven3.x搭建私服构件仓库

    前言 在笔者的前一篇博文<Use Maven3.x>中,笔者详细的讲解了如何通过使用Maven3.x来构建及管理你的项目.其中笔者提到过些关于私服的概念,但却没有明确的对私服做出详细的阐述 ...

  3. iomanip的作用 C++

    c++程序里面经常见到下面的头文件 #include <iomanip> 这里面iomanip的作用比较多: 主要是对cin,cout之类的一些操纵运算子,比如setfill,setw,s ...

  4. C#设计模式六大原则概述

    在面向对象的设计中,我们应当遵循以下六大原则,只有掌握了这些原则,才能更好的理解设计模式. 1:单一职责原则(Single Responsibility Principle 简称 :SRP) : 就一 ...

  5. MathJax: 让前端支持数学公式

    文章图片存储在GitHub,网速不佳的朋友,请看<MathJax:让前端支持数学公式> 或者 来我的技术小站 godbmw.com 1. 必须要说 1.1 开发背景 博主使用Vue开发的个 ...

  6. 机器学习实战 - python3 学习笔记(一) - k近邻算法

    一. 使用k近邻算法改进约会网站的配对效果 k-近邻算法的一般流程: 收集数据:可以使用爬虫进行数据的收集,也可以使用第三方提供的免费或收费的数据.一般来讲,数据放在txt文本文件中,按照一定的格式进 ...

  7. vue-cli脚手架之package.json

    package.json文件配置及其含义,这个是vue-cli自动生成的文件,先贴一张代码及其含义: { "name": "secondproject",//模 ...

  8. 纯小白入手 vue3.0 CLI - 3.3 - 路由的导航守卫

    vue3.0 CLI 真小白一步一步入手全教程系列:https://www.cnblogs.com/ndos/category/1295752.html 尽量把纷繁的知识,肢解重组成为可以堆砌的知识. ...

  9. 《Inside C#》笔记(十五) 非托管代码 上

    为了保证向后兼容性,C#和.NET可以通过非托管的方式运行旧代码.非托管代码是指没有被.NET运行时管控的代码.非托管代码主要包括:平台调用服务(PlatformInvocation Services ...

  10. 慕学在线网0.2_users表设计(1)

    1.Django App设计: users-用户管理(任何web中,users表都是第一个被设计的) course-课程管理 organization-机构和教师管理 operation-用户操作管理 ...