首页 > 其他分享 >Go每日一库之51：gabs

Go每日一库之51：gabs

时间：2023-09-28 14:36:51浏览次数：82  
标签：name age 51 gabs jObj 一库 user Go fmt

简介

JSON 是一种非常流行的数据交换格式。每种编程语言都有很多操作 JSON 的库，标准库、第三方库都有。Go 语言中标准库内置了 JSON 操作库encoding/json。我们之前也介绍过专门用于查询 JSON 串的库gjson和专门用于修改 JSON 串的库sjson，还有一个非常方便的操作 JSON 数据的命令行工具jj。今天我们再介绍一个 JSON 工具库——gabs。gabs是一个用来查询和修改 JSON 串的库。它使用encoding/json将一般的 JSON 串转为map[string]interface{}，并提供便利的方法操作map[string]struct{}。

快速使用

本文代码使用 Go Modules。

创建目录并初始化：

$ mkdir gabs && cd gabs
$ go mod init github.com/go-quiz/go-daily-lib/gabs

安装gabs，目前最新版本为v2，推荐使用v2：

$ go get -u github.com/Jeffail/gabs/v2

使用：

package main

import (
  "github.com/Jeffail/gabs/v2"
  "fmt"
)

func main() {
  jObj, _ := gabs.ParseJSON([]byte(`{
    "info": {
      "name": {
        "first": "lee",
        "last": "go-quiz"
      },
      "age": 18,
      "hobbies": [
        "game",
        "programming"
      ]
    }
    }`))

  fmt.Println("first name: ", jObj.Search("info", "name", "first").Data().(string))
  fmt.Println("second name: ", jObj.Path("info.name.last").Data().(string))
  gObj, _ := jObj.JSONPointer("/info/age")
  fmt.Println("age: ", gObj.Data().(float64))
  fmt.Println("one hobby: ", jObj.Path("info.hobbies.1").Data().(string))
}

首先，我们调用gabs.ParseJSON()方法解析传入的 JSON 串，得到一个gabs.Container对象。后续通过该gabs.Container对象来查询和修改解析出来的数据。

gabs提供 3 种查询方式：

  • 以.分隔的路径调用Path()方法；
  • 将路径各个部分作为可变参数传入Search()方法；
  • 使用/分隔的路径调用JSONPointer()方法。

上述方法内部实现最终都是调用相同的方法，只是使用上稍微有些区别。注意：

  • 3 个方法最终都返回一个gabs.Container对象，我们需要调用其Data()获取内部的数据，然后做一次类型转换得到实际的数据；
  • 如果传入的路径有误或路径下无数据，则Search/Path方法返回的gabs.Container对象内部数据为nil，即Data()方法返回nil，而JSONPointer方法返回err。实际使用时注意进行空指针和错误判断；
  • 如果路径某个部分对应的数据类型为数组，则可以在后面追加索引，读取对应索引下的数据，如info.hobbies.1；
  • JSONPointer()参数必须以/开头。

运行结果：

$ go run main.go
first name:  lee
second name:  go-quiz
age:  18
one hobby:  programming

查询 JSON 串

上一节中我们介绍过，在gabs中，路径有 3 种表示方式。这 3 种方式对应 3 个基础的查询方法：

  • Search(hierarchy ...string)：也有一个简写形式S；
  • Path(path string)：path以.分隔；
  • JSONPointer(path string)：path以/分隔。

它们的基本用法上面已经介绍过了，对于数组我们还能对每个数组元素做递归查询。在下面例子中，我们依次返回数组members中每个元素的name、age和relation字段：

func main() {
  jObj, _ := gabs.ParseJSON([]byte(`{
    "user": {
      "name": "dj",
      "age": 18,
      "members": [
        {
          "name": "hjw",
          "age": 20,
          "relation": "spouse"
        },
        {
          "name": "lizi",
          "age": 3,
          "relation": "son"
        }
      ]
    }
  }`))

  fmt.Println("member names: ", jObj.S("user", "members", "*", "name").Data())
  fmt.Println("member ages: ", jObj.S("user", "members", "*", "age").Data())
  fmt.Println("member relations: ", jObj.S("user", "members", "*", "relation").Data())

  fmt.Println("spouse name: ", jObj.S("user", "members", "0", "name").Data().(string))
}

运行程序，输出：

$ go run main.go
member names:  [hjw lizi]
member ages:  [20 3]
member relations:  [spouse son]
spouse name:  hjw

容易看出，在路径中遇到数组分下面两种情况处理：

  • 下一个部分路径是*，则对所有的数组元素应用剩余的路径查询，结果放在一个数组中返回；
  • 否则，下一个路径部分必须是数组索引，对该索引所在元素应用剩余的路径查询。

查看源码我们可以知道，实际上，Path/JSONPointer内部都是先将path解析为hierarchy ...string的形式，最终都会调用searchStrict方法：

func (g *Container) Search(hierarchy ...string) *Container {
  c, _ := g.searchStrict(true, hierarchy...)
  return c
}

func (g *Container) Path(path string) *Container {
  return g.Search(DotPathToSlice(path)...)
}

func (g *Container) JSONPointer(path string) (*Container, error) {
  hierarchy, err := JSONPointerToSlice(path)
  if err != nil {
    return nil, err
  }
  return g.searchStrict(false, hierarchy...)
}

func (g *Container) S(hierarchy ...string) *Container {
  return g.Search(hierarchy...)
}

searchStrict方法也不复杂，我们简单看一下：

func (g *Container) searchStrict(allowWildcard bool, hierarchy ...string) (*Container, error) {
  object := g.Data()
  for target := 0; target < len(hierarchy); target++ {
    pathSeg := hierarchy[target]
    if mmap, ok := object.(map[string]interface{}); ok {
      object, ok = mmap[pathSeg]
      if !ok {
        return nil, fmt.Errorf("failed to resolve path segment '%v': key '%v' was not found", target, pathSeg)
      }
    } else if marray, ok := object.([]interface{}); ok {
      if allowWildcard && pathSeg == "*" {
        tmpArray := []interface{}{}
        for _, val := range marray {
          if (target + 1) >= len(hierarchy) {
            tmpArray = append(tmpArray, val)
          } else if res := Wrap(val).Search(hierarchy[target+1:]...); res != nil {
            tmpArray = append(tmpArray, res.Data())
          }
        }
        if len(tmpArray) == 0 {
          return nil, nil
        }
        return &Container{tmpArray}, nil
      }
      index, err := strconv.Atoi(pathSeg)
      if err != nil {
        return nil, fmt.Errorf("failed to resolve path segment '%v': found array but segment value '%v' could not be parsed into array index: %v", target, pathSeg, err)
      }
      if index < 0 {
        return nil, fmt.Errorf("failed to resolve path segment '%v': found array but index '%v' is invalid", target, pathSeg)
      }
      if len(marray) <= index {
        return nil, fmt.Errorf("failed to resolve path segment '%v': found array but index '%v' exceeded target array size of '%v'", target, pathSeg, len(marray))
      }
      object = marray[index]
    } else {
      return nil, fmt.Errorf("failed to resolve path segment '%v': field '%v' was not found", target, pathSeg)
    }
  }
  return &Container{object}, nil
}

实际上就是顺着路径一层层往下走，遇到数组。如果下一个部分是通配符*，下面是处理代码：

tmpArray := []interface{}{}
for _, val := range marray {
  if (target + 1) >= len(hierarchy) {
    tmpArray = append(tmpArray, val)
  } else if res := Wrap(val).Search(hierarchy[target+1:]...); res != nil {
    tmpArray = append(tmpArray, res.Data())
  }
}
if len(tmpArray) == 0 {
  return nil, nil
}
return &Container{tmpArray}, nil

如果*是路径最后一个部分，返回所有数组元素：

if (target + 1) >= len(hierarchy) {
  tmpArray = append(tmpArray, val)
}

否则，应用剩余的路径查询每个元素，查询结果append到待返回切片中：

else if res := Wrap(val).Search(hierarchy[target+1:]...); res != nil {
  tmpArray = append(tmpArray, res.Data())
}

另一方面，如果不是通配符，那么下一个路径部分必须是索引，取这个索引的元素，继续往下查询：

index, err := strconv.Atoi(pathSeg)

遍历

gabs提供了两个方法可以方便地遍历数组和对象：

  • Children()：返回所有数组元素的切片，如果在对象上调用该方法，Children()将以不确定顺序返回对象所有的值的切片；
  • ChildrenMap()：返回对象的键和值。

看示例：

func main() {
  jObj, _ := gabs.ParseJSON([]byte(`{
    "user": {
      "name": "dj",
      "age": 18,
      "members": [
        {
          "name": "hjw",
          "age": 20,
          "relation": "spouse"
        },
        {
          "name": "lizi",
          "age": 3,
          "relation": "son"
        }
      ]
    }
  }`))

  for k, v := range jObj.S("user").ChildrenMap() {
    fmt.Printf("key: %v, value: %v\n", k, v)
  }

  fmt.Println()

  for i, v := range jObj.S("user", "members", "*").Children() {
    fmt.Printf("member %d: %v\n", i+1, v)
  }
}

运行结果：

$ go run main.go
key: name, value: "dj"
key: age, value: 18
key: members, value: [{"age":20,"name":"hjw","relation":"spouse"},{"age":3,"name":"lizi","relation":"son"}]

member 1: {"age":20,"name":"hjw","relation":"spouse"}
member 2: {"age":3,"name":"lizi","relation":"son"}

这两个方法的源码很简单，建议去看看~

存在性判断

gabs提供了两个方法检查对应的路径上是否存在数据：

  • Exists(hierarchy ...string)；
  • ExistsP(path string)：方法名以P结尾，表示接受以.分隔的路径。

看示例：

func main() {
  jObj, _ := gabs.ParseJSON([]byte(`{"user":{"name": "dj","age": 18}}`))
  fmt.Printf("has name? %t\n", jObj.Exists("user", "name"))
  fmt.Printf("has age? %t\n", jObj.ExistsP("user.age"))
  fmt.Printf("has job? %t\n", jObj.Exists("user", "job"))
}

运行：

$ go run main.go
has name? true
has age? true
has job? false

获取数组信息

对于类型为数组的值，gabs提供了几组便捷的查询方法。

  • 获取数组大小：ArrayCount/ArrayCountP，不加后缀的方法接受可变参数作为路径，以P为后缀的方法需要传入.分隔的路径；
  • 获取数组某个索引的元素：ArrayElement/ArrayElementP。

示例：

func main() {
  jObj, _ := gabs.ParseJSON([]byte(`{
    "user": {
      "name": "dj",
      "age": 18,
      "members": [
        {
          "name": "hjw",
          "age": 20,
          "relation": "spouse"
        },
        {
          "name": "lizi",
          "age": 3,
          "relation": "son"
        }
      ],
      "hobbies": ["game", "programming"]
    }
  }`))

  cnt, _ := jObj.ArrayCount("user", "members")
  fmt.Println("member count:", cnt)
  cnt, _ = jObj.ArrayCount("user", "hobbies")
  fmt.Println("hobby count:", cnt)

  ele, _ := jObj.ArrayElement(0, "user", "members")
  fmt.Println("first member:", ele)
  ele, _ = jObj.ArrayElement(1, "user", "hobbies")
  fmt.Println("second hobby:", ele)
}

输出：

member count: 2
hobby count: 2
first member: {"age":20,"name":"hjw","relation":"spouse"}
second hobby: "programming"

修改和删除

我们可以使用gabs构造一个 JSON 串。根据要设置的值的类型，gabs将修改的方法又分为了两类：原始值、数组和对象。基本操作流程是相同的：

  • 调用gabs.New()创建gabs.Container对象，或者ParseJSON()从现有 JSON 串中解析出gabs.Container对象；
  • 调用方法设置或修改键值，也可以删除一些键；
  • 生成最终的 JSON 串。

原始值

我们前面说过，gabs使用三种方式来表达路径。在设置时也可以通过这三种方式指定在什么位置设置值。对应方法为：

  • Set(value interface{}, hierarchy ...string)：将路径各个部分作为可变参数传入即可；
  • SetP(value interface{}, path string)：路径各个部分以点.分隔；
  • SetJSONPointer(value interface{}, path string)：路径各个部分以/分隔，且必须以/开头。

示例：

func main() {
  gObj := gabs.New()

  gObj.Set("lee", "info", "name", "first")
  gObj.SetP("go-quiz", "info.name.last")
  gObj.SetJSONPointer(18, "/info/age")

  fmt.Println(gObj.String())
}

最终生成 JSON 串：

$ go run main.go
{"info":{"age":18,"name":{"first":"lee","last":"go-quiz"}}}

我们也可以调用gabs.Container的StringIndent方法增加前缀和缩进，让输出更美观些：

fmt.Println(gObj.StringIndent("", "  "))

观察输出变化：

$ go run main.go
{
  "info": {
    "age": 18,
    "name": {
      "first": "lee",
      "last": "go-quiz"
    }
  }
}

数组

相比原始值，数组的操作复杂不少。我们可以创建新的数组，也可以在原有的数组中添加、删除元素。

func main() {
  gObj := gabs.New()

  arrObj1, _ := gObj.Array("user", "hobbies")
  fmt.Println(arrObj1.String())

  arrObj2, _ := gObj.ArrayP("user.bugs")
  fmt.Println(arrObj2.String())

  gObj.ArrayAppend("game", "user", "hobbies")
  gObj.ArrayAppend("programming", "user", "hobbies")

  gObj.ArrayAppendP("crash", "user.bugs")
  gObj.ArrayAppendP("panic", "user.bugs")
  fmt.Println(gObj.String())
}

我们先通过Array/ArrayP分别在路径user.hobbies和user.bugs下创建数组，然后调用ArrayAppend/ArrayAppendP向这两个数组中添加元素。现在我们应该可以根据方法有无后缀，后缀是什么来区分它接受什么格式的路径了！

运行结果：

{"user":{"bugs":["crash","panic"],"hobbies":["game","programming"]}}

实际上，我们甚至可以省略上面的数组创建过程，因为ArrayAppend/ArrayAppendP如果检测到中间路径上没有值，会自动创建对象。

当然我们也可以删除某个索引的数组元素，使用ArrayRemove/ArrayRemoveP方法：

func main() {
  jObj, _ := gabs.ParseJSON([]byte(`{"user":{"bugs":["crash","panic"],"hobbies":["game","programming"]}}`))

  jObj.ArrayRemove(0, "user", "bugs")
  jObj.ArrayRemoveP(1, "user.hobbies")
  fmt.Println(jObj.String())
}

删除完成之后还剩下：

{"user":{"bugs":["panic"],"hobbies":["game"]}}

对象

在指定路径下创建对象使用Object/ObjectI/ObjectP这组方法，其中ObjectI是指在数组的特定索引下创建。一般地我们使用Set类方法就足够了，中间路径不存在会自动创建。

对象删除使用Delete/DeleteP这组方法：

func main() {
  jObj, _ := gabs.ParseJSON([]byte(`{"info":{"age":18,"name":{"first":"lee","last":"go-quiz"}}}`))

  jObj.Delete("info", "name")
  fmt.Println(jObj.String())

  jObj.Delete("info")
  fmt.Println(jObj.String())
}

输出：

{"info":{"age":18}}
{}

Flatten

Flatten操作即将嵌套很深的字段提到最外层，gabs.Flatten返回一个新的map[string]interface{}，interface{}为 JSON 中叶子节点的值，键为该叶子的路径。例如：{"foo":[{"bar":"1"},{"bar":"2"}]}执行 flatten 操作之后返回{"foo.0.bar":"1","foo.1.bar":"2"}。

func main() {
  jObj, _ := gabs.ParseJSON([]byte(`{
    "user": {
      "name": "dj",
      "age": 18,
      "members": [
        {
          "name": "hjw",
          "age": 20,
          "relation": "spouse"
        },
        {
          "name": "lizi",
          "age": 3,
          "relation": "son"
        }
      ],
      "hobbies": ["game", "programming"]
    }
  }`))

  obj, _ := jObj.Flatten()
  fmt.Println(obj)
}

输出：

map[user.age:18 user.hobbies.0:game user.hobbies.1:programming user.members.0.age:20 user.members.0.name:hjw user.members.0.relation:spouse user.members.1.age:3 user.members.1.name:lizi user.members.1.relation:son user.name:dj]

合并

我们可以将两个gabs.Container合并成一个。如果同一个路径下有相同的键：

  • 如果两者都是对象类型，则对二者进行合并操作；
  • 如果两者都是数组类型，则将后者中所有元素追加到前一个数组中；
  • 其中一个为数组，合并之后另一个同名键的值将会作为元素添加到数组中。

例如：

func main() {
  obj1, _ := gabs.ParseJSON([]byte(`{"user":{"name":"dj"}}`))
  obj2, _ := gabs.ParseJSON([]byte(`{"user":{"age":18}}`))
  obj1.Merge(obj2)
  fmt.Println(obj1)

  arr1, _ := gabs.ParseJSON([]byte(`{"user": {"hobbies": ["game"]}}`))
  arr2, _ := gabs.ParseJSON([]byte(`{"user": {"hobbies": ["programming"]}}`))
  arr1.Merge(arr2)
  fmt.Println(arr1)

  obj3, _ := gabs.ParseJSON([]byte(`{"user":{"name":"dj", "hobbies": "game"}}`))
  arr3, _ := gabs.ParseJSON([]byte(`{"user": {"hobbies": ["programming"]}}`))
  obj3.Merge(arr3)
  fmt.Println(obj3)

  obj4, _ := gabs.ParseJSON([]byte(`{"user":{"name":"dj", "hobbies": "game"}}`))
  arr4, _ := gabs.ParseJSON([]byte(`{"user": {"hobbies": ["programming"]}}`))
  arr4.Merge(obj4)
  fmt.Println(arr4)

  obj5, _ := gabs.ParseJSON([]byte(`{"user":{"name":"dj", "hobbies": {"first": "game"}}}`))
  arr5, _ := gabs.ParseJSON([]byte(`{"user": {"hobbies": ["programming"]}}`))
  obj5.Merge(arr5)
  fmt.Println(obj5)
}

看结果：

{"user":{"age":18,"name":"dj"}}
{"user":{"hobbies":["game","programming"]}}
{"user":{"hobbies":["game","programming"],"name":"dj"}}
{"user":{"hobbies":["programming","game"],"name":"dj"}}
{"user":{"hobbies":[{"first":"game"},"programming"],"name":"dj"}}

总结

gabs是一个十分方便的操作 JSON 的库，非常易于使用，而且代码实现比较简洁，值得一看。

大家如果发现好玩、好用的 Go 语言库，欢迎到 Go 每日一库 GitHub 上提交 issue

参考

  1. gabs GitHub：https://github.com/Jeffail/gabs
  2. Go 每日一库 GitHub：https://github.com/go-quiz/go-daily-lib

标签：name,age,51,gabs,jObj,一库,user,Go,fmt
From： https://www.cnblogs.com/arena/p/17735711.html

相关文章

  • Go每日一库之50：jobrunner
    简介我们在Web开发中时常会遇到这样的需求，执行一个操作之后，需要给用户一定形式的通知。例如，用户下单之后通过邮件发送电子发票，网上购票支付后通过短信发送车次信息。但是这类需求并不需要非常及时，如果放在请求流程中处理，会影响请求的响应时间。这类任务我们一般使用异步的方式......
  • Go每日一库之49：mapstructure
    简介mapstructure用于将通用的map[string]interface{}解码到对应的Go结构体中，或者执行相反的操作。很多时候，解析来自多种源头的数据流时，我们一般事先并不知道他们对应的具体类型。只有读取到一些字段之后才能做出判断。这时，我们可以先使用标准的encoding/json库将数据解码为map......
  • Go每日一库之70：termtables
    简介今天学个简单点的，termtables处理表格形式数据的输出。适用于随时随地的输出一些状态或统计数据，便于观察和调试。是一个很小巧的工具库。我在学习dateparse库时偶尔见遇到了这个库。快速使用本文代码使用GoModules。创建目录并初始化：$mkdirtermtables&&cdtermtable......
  • Go每日一库之69：resty
    简介resty是Go语言的一个HTTPclient库。resty功能强大，特性丰富。它支持几乎所有的HTTP方法（GET/POST/PUT/DELETE/OPTION/HEAD/PATCH等），并提供了简单易用的API。快速使用本文代码使用GoModules。创建目录并初始化：$mkdirresty&&cdresty$gomodinitgithub.com/......
  • golang-channel
    什么是channel管道channel是goroutine与goroutine之间通信的重要桥梁channel是一个通道，用于端到端的数据传输，这有点像我们平常使用的消息队列，只不过channel的发送方和接受方是 goroutine 对象，属于内存级别的通信。这里涉及到了goroutine概念，goroutine是轻量级的......
  • gom引擎微端架设教程
    在配置GOM微端之前呢，首先我们需要在服务器里面准备好1.传奇版本2.版本配套的补丁3.完整传奇客户端（推荐使用15到17周年的）4.微端程序。这些准备好，下面我们就可以直接架设了。首先呢需要把版本解压到D盘，然后把补丁解压到客户端里面，接着我们打开引擎包，引擎包里面有微端程序给程序放到桌......
  • 随想录Day8|344. 反转字符串、541. 反转字符串Ⅱ、LCR 122. 路径加密、151. 反转字符
    随想录Day8|344.反转字符串、541.反转字符串Ⅱ、LCR122.路径加密、151.反转字符串里的单词、LCR182.动态口令 题目越来越长了…… 344.反转字符串文章&视频讲解编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组s的形式给出。不要给另外的数......
  • GO基础环境搭建GoLand
    一、GO官方资料官网：https://golang.org/gosdk下载：https://golang.google.cn/dl/golang中文社区：https://studygolang.com/dl中文社区文档https://studygolang.com/pkgdoc二、开发环境配置1、GOSDK下载后,自行安装go语言开发需要使用gosdk,下载链接https://go.dev/dl/下载......
  • go go代码中调用python脚本
    目录gogo代码中调用python脚本写个简单的py脚本再写个go的脚本gogo代码中调用python脚本有的官方文档只提供了java和python的sdk，而我们需要用他们封装的服务，只能调用python或java的接口，接下来演示怎么调用python写个简单的py脚本importsysdefmain():args1=sys.ar......
  • Go每日一库之28：validator
    简介今天我们来介绍一个非常实用的库——validator。validator用于对数据进行校验。在Web开发中，对用户传过来的数据我们都需要进行严格校验，防止用户的恶意请求。例如日期格式，用户年龄，性别等必须是正常的值，不能随意设置。快速使用先安装：$gogetgopkg.in/go-playground/vali......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99