go-simplejson文档学习

最新推荐文章于 2024-11-06 02:23:01 发布
最新推荐文章于 2024-11-06 02:23:01 发布
阅读量237 收藏
点赞数
文章标签： json
原文链接：http://www.cnblogs.com/wanghui-garcia/p/10432185.html
版权

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

 

转载于:https://www.cnblogs.com/wanghui-garcia/p/10432185.html

weixin_34236497
关注
go-simplejson：Go包，可与任意JSON交互
02-20
`go-simplejson`是Go语言中的一个第三方库，专门用于处理JSON数据，它提供了一种更灵活、更方便的方式来解析和操作JSON。在Go的内置`encoding/json`包中，虽然已经提供了对JSON的支持，但`go-simplejson`进一步简化...
推荐：go-simplejson - 简单易用的 Go 语言 JSON 库
gitblog_00099的博客
03-16 639
推荐：go-simplejson - 简单易用的 Go 语言 JSON 库 项目地址:https://gitcode.com/gh_mirrors/go/go-simplejson 项目简介 go-simplejson 是一个基于 Go 语言的简单、易用的 JSON 库，旨在提供更简单的 JSON 操作方式。 功能特性 支持直接操作 JSON 数据。 提供了类似 JavaScript 的 API...
golang之JSON处理
农家小舍
01-15 7403
介绍了JSON的序列化与反序列化，以及如何自定义序列化（MarshalJSON）与反序列化（UnmarshalJSON）方法；开优酷go-simplejson的使用方法
go simplejson
YAYA776的博客
07-28 783
包： import ( "github.com/bitly/go-simplejson" ) 用法： 第一步，得到json的内容 contents, _ := ioutil.ReadAll(res.Body) js, js_err := simplejson.NewJson(contents) 第二步，根据json的格式，选择使用array或者map储存数据 var nodes = ...
go-simplejson 项目教程
gitblog_01099的博客
08-13 337
go-simplejson 项目教程 go-simplejsona Go package to interact with arbitrary JSON项目地址:https://gitcode.com/gh_mirrors/go/go-simplejson 1. 项目的目录结构及介绍 go-simplejson 项目的目录结构如下： go-simplejson/ ├── LICENSE ├── ...
python-simplejson-3.5.3-5.el7.x86_64(1).rpm
12-04
官方离线安装包，亲测可用
python27-python-simplejson-3.2.0-3.el7.x86_64.rpm
01-02
官方离线安装包，测试可用。使用rpm -ivh [rpm完整包名] 进行安装
python-simplejson-3.5.3-5.el7.x86_64.rpm
12-04
官方离线安装包，亲测可用
python-simplejson-debugsource-3.17.0-1.el8.aarch64.rpm
12-05
离线安装包，亲测可用
Go使用simple-json解析json数组字符串：以Harbor获取镜像tag为例
学亮编程手记
12-21 753
package main import ( "encoding/json" "fmt" "io/ioutil" "net/http" simplejson "github.com/bitly/go-simplejson" ) func main() { // 这里需要注意地址中/的转义 // 使用%252F转义"/" url := "http://192.168.112.111:1903/api/v2.0/projects/test/repositories/zhangxueliang
go-simplejson|解析json字符串
weixin_40592935的博客
07-04 1899
go-simplejson|解析json字符串阅读数：3376package main import ( "github.com/bitly/go-simplejson" // for json get "fmt") var jsonStr = ` { "person": [{ "name": "piao...
go-simplejson遇到的一些小问题的笔记
DerWeltraum
03-03 2231
最近在使用go写一些项目，为了图方便，使用了go的json解析库go-simplejson（https://github.com/bitly/go-simplejson）。 因为自己经验比较缺乏，遇见了一些小问题，特意在这里记录一下，以供自己日后查阅。 首先自己要解析的json如下： { errorCode: 0, message: "操作成功", result: { data:{ ...
go-simplejson 项目常见问题解决方案
最新发布
gitblog_00592的博客
11-06 591
go-simplejson 项目常见问题解决方案 go-simplejson a Go package to interact with arbitrary JSON 项目地址: https://gitcode.com/gh_mi...
go 学习 go-simplejson 遍历
点滴生活
09-12 1173
方式一 dataJson := jsonInfo.Get("tick").Get("data") dataArr, _ := dataJson.Array() // 遍历 for i := range dataArr { info := dataJson.GetIndex(i) priceF := info.Get("price").MustFloat64() amountF := info.Get("amount").MustFloat64() direc..
go解析复杂json数组字符串：结合使用json和simple-json库
学亮编程手记
12-21 1194
原始json数组字符串 [ { "addition_links": { "build_history": { "absolute": false, "href": "/api/v2.0/projects/test/repositories/zhangxueliang%252Fmyapp/artifacts/sha256:5f4afc8302ade316fc47c99ee1d41f8ba94dbe7
org.json.simple使用详解
北雨南萍
09-24 2万+
一、概览 JSON.simple是一个很简单的JSON处理，读取和写JSON数据的JAVA库， 它完全兼容JSON的标准(RFC4627). 你可以用JSON.simple来编码或解码JSON文本。 【NOTE】 如果想将对象转换成JOSN，或将JSON转换成对象，你需要考虑使用Jackson或Gson。 二、功能 JSON.simple的功能:  . 完全兼容
golang 处理Json 数组
热门推荐
unclebig小胖的专栏
06-06 2万+
今天遇到个接口需要处理一个json的map类型的数组，开始想法是用simple—json里的Array读取数组，然后遍历数组取出每个map，然后读取对应的值，在进行后续操作，貌似很简单的工作，却遇到了一个陷阱。 Json格式类似下边： {"code":0 ,"request_id": xxxx ,"code_msg":"" ,"body":[{ "device_id": "
yum install python-simplejson -y报错
09-04
当在终端运行命令"yum install python-simplejson -y"时，如果出现报错信息，通常是因为以下原因之一： 1. 无法找到软件包：发生这种情况可能是因为软件包名称输入错误或者软件包源中没有包含该软件包。请确保正确...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值