go语言gabs库的使用

 1 import "fmt"
 2 import "github.com/Jeffail/gabs"
 3 
 4 //1、Search + path 使用方法
 5 func main() {
 6     jObj, _ := gabs.ParseJSON([]byte(
 7         `
 8 {
 9     "info": {
10         "name": {
11             "first": "lee",
12             "last": "darjun"
13         },
14         "age": 18,
15         "hobbies": [
16             "game",
17             "programming"
18         ]
19     }
20 }
21 `))
22     //如果传入的路径有误或路径下无数据，则Search/Path方法返回的gabs.Container对象内部数据为nil，即Data()方法返回nil
23     fmt.Println("first name: ", jObj.Search("info", "name", "first").Data())
24     fmt.Println("second name: ", jObj.Path("info.name.last").Data())
25     fmt.Println("one hobby: ", jObj.Path("info.hobbies").Index(1).Data())
26 }

 1 import "fmt"
 2 import "github.com/Jeffail/gabs"
 3 
 4 //2、S——递归查询
 5 func main() {
 6     jObj, _ := gabs.ParseJSON([]byte(
 7         `
 8     {
 9         "user": {
10             "name": "dj",
11             "age": 18,
12             "members": [{
13                     "name": "hjw",
14                     "age": 20,
15                     "relation": "spouse"
16                 },
17                 {
18                     "name": "lizi",
19                     "age": 3,
20                     "relation": "son"
21                 }
22             ]
23         }
24     }
25 `))
26 
27     fmt.Println("member names: ", jObj.S("user", "members", "name").Data())
28     fmt.Println("member ages: ", jObj.S("user", "members", "age").Data())
29     fmt.Println("member relations: ", jObj.S("user", "members", "relation").Data())
30     fmt.Println("spouse name: ", jObj.S("user", "members").Index(0).S("name").Data())
31 }

 1 import "fmt"
 2 import "github.com/Jeffail/gabs"
 3 
 4 //3、
 5 //3.1：Children()：返回所有数组元素的切片，如果在对象上调用该方法，Children()将以不确定顺序返回对象所有的值的切片；
 6 //3.2：ChildrenMap()：返回对象的键和值。
 7 func main() {
 8     jObj, _ := gabs.ParseJSON([]byte(
 9         `
10     {
11         "user": {
12             "name": "dj",
13             "age": 18,
14             "members": [{
15                     "name": "hjw",
16                     "age": 20,
17                     "relation": "spouse"
18                 },
19                 {
20                     "name": "lizi",
21                     "age": 3,
22                     "relation": "son"
23                 }
24             ]
25         }
26     }
27 `))
28 
29     KeyValue,_ := jObj.S("user").ChildrenMap()
30     for k, v := range KeyValue {
31         fmt.Printf("key: %v, value: %v\n", k, v)
32     }
33 
34     fmt.Println()
35 
36     Value,_ := jObj.S("user", "members").Children()
37     for i, v := range Value {
38         fmt.Printf("member %d: %v\n", i+1, v)
39     }
40 }

 1 //4
 2 //4.1:Exists(hierarchy ...string)；
 3 //4.2:ExistsP(path string)：方法名以P结尾，表示接受以.分隔的路径。
 4 func main() {
 5     jObj, _ := gabs.ParseJSON([]byte(
 6         `
 7     {
 8         "user": {
 9             "name": "dj",
10             "age": 18
11         }
12     }
13 `))
14     fmt.Printf("has name? %t\n", jObj.Exists("user", "name"))
15     fmt.Printf("has age? %t\n", jObj.ExistsP("user.age"))
16     fmt.Printf("has job? %t\n", jObj.Exists("user", "job"))
17 }

 1 //5、
 2 //5.1：获取数组大小：ArrayCount/ArrayCountP，不加后缀的方法接受可变参数作为路径，以P为后缀的方法需要传入.分隔的路径；
 3 //5.2：获取数组某个索引的元素：ArrayElement/ArrayElementP。
 4 func main() {
 5     jObj, _ := gabs.ParseJSON([]byte(
 6         `
 7     {
 8         "user": {
 9             "name": "dj",
10             "age": 18,
11             "members": [{
12                     "name": "hjw",
13                     "age": 20,
14                     "relation": "spouse"
15                 },
16                 {
17                     "name": "lizi",
18                     "age": 3,
19                     "relation": "son"
20                 }
21             ],
22             "hobbies": ["game", "programming"]
23         }
24     }
25 `))
26 
27     cnt, _ := jObj.ArrayCount("user", "members")
28     fmt.Println("member count:", cnt)
29     cnt, _ = jObj.ArrayCount("user", "hobbies")
30     fmt.Println("hobby count:", cnt)
31 
32     ele, _ := jObj.ArrayElement(0, "user", "members")
33     fmt.Println("first member:", ele)
34     ele, _ = jObj.ArrayElement(1, "user", "hobbies")
35     fmt.Println("second hobby:", ele)
36 }

 1 //6、
 2 //6.1：Set(value interface{}, hierarchy ...string)：将路径各个部分作为可变参数传入即可；
 3 //6.2：SetP(value interface{}, path string)：路径各个部分以点.分隔；
 4 func main() {
 5     gObj := gabs.New()
 6 
 7     gObj.Set("lee", "info", "name", "first")
 8     gObj.SetP("darjun", "info.name.last")
 9     gObj.SetP(18, "info.age")
10 
11     fmt.Println(gObj.StringIndent("", "  "))
12 }

 1 //7、
 2 //7.1：通过Array/ArrayP分别在路径user.hobbies和user.bugs下创建数组，
 3 //7.2：然后调用ArrayAppend/ArrayAppendP向这两个数组中添加元素
 4 func main() {
 5     gObj := gabs.New()
 6 
 7     arrObj1, _ := gObj.Array("user", "hobbies")
 8     fmt.Println(arrObj1.String())
 9 
10     arrObj2, _ := gObj.ArrayP("user.bugs")
11     fmt.Println(arrObj2.String())
12 
13     gObj.ArrayAppend("game", "user", "hobbies")
14     gObj.ArrayAppend("programming", "user", "hobbies")
15 
16     gObj.ArrayAppendP("crash", "user.bugs")
17     gObj.ArrayAppendP("panic", "user.bugs")
18     fmt.Println(gObj.StringIndent("", "  "))
19 }

 1 //8、对象删除使用Delete/DeleteP这组方法
 2 func main() {
 3     jObj, _ := gabs.ParseJSON([]byte(
 4         `
 5     {
 6         "info": {
 7             "age": 18,
 8             "name": {
 9                 "first": "lee",
10                 "last": "darjun"
11             }
12         }
13     }
14 `))
15     fmt.Println(jObj.StringIndent("", "  "))
16 
17     jObj.Delete("info", "name")
18     fmt.Println(jObj.StringIndent("", "  "))
19 
20     jObj.Delete("info")
21     fmt.Println(jObj.StringIndent("", "  "))
22 }

 1 //9、删除某个索引的数组元素，使用ArrayRemove/ArrayRemoveP方法
 2 func main() {
 3     jObj, _ := gabs.ParseJSON([]byte(
 4         `
 5     {
 6         "user": {
 7             "bugs": ["crash", "panic"],
 8             "hobbies": ["game", "programming"]
 9         }
10     }
11 `))
12 
13     jObj.ArrayRemove(0, "user", "bugs")
14     fmt.Println(jObj.StringIndent("", "  "))
15     fmt.Println()
16     jObj.ArrayRemoveP(1, "user.hobbies")
17     fmt.Println(jObj.StringIndent("", "  "))
18 }

 1 //10、我们可以将两个gabs.Container合并成一个。如果同一个路径下有相同的键：
 2     //10.1、如果两者都是对象类型，则对二者进行合并操作；
 3     //10.2、如果两者都是数组类型，则将后者中所有元素追加到前一个数组中；
 4     //10.3、其中一个为数组，合并之后另一个同名键的值将会作为元素添加到数组中。
 5 func main() {
 6     obj1, _ := gabs.ParseJSON([]byte(`{"user":{"name":"dj"}}`))
 7     obj2, _ := gabs.ParseJSON([]byte(`{"user":{"age":18}}`))
 8     obj1.Merge(obj2)
 9     fmt.Println(obj1.StringIndent("", "  "))
10 
11     arr1, _ := gabs.ParseJSON([]byte(`{"user": {"hobbies": ["game"]}}`))
12     arr2, _ := gabs.ParseJSON([]byte(`{"user": {"hobbies": ["programming"]}}`))
13     arr1.Merge(arr2)
14     fmt.Println(arr1.StringIndent("", "  "))
15 
16     obj3, _ := gabs.ParseJSON([]byte(`{"user":{"name":"dj", "hobbies": "game"}}`))
17     arr3, _ := gabs.ParseJSON([]byte(`{"user": {"hobbies": ["programming"]}}`))
18     obj3.Merge(arr3)
19     fmt.Println(obj3.StringIndent("", "  "))
20 
21     obj4, _ := gabs.ParseJSON([]byte(`{"user":{"name":"dj", "hobbies": "game"}}`))
22     arr4, _ := gabs.ParseJSON([]byte(`{"user": {"hobbies": ["programming"]}}`))
23     arr4.Merge(obj4)
24     fmt.Println(arr4.StringIndent("", "  "))
25 
26     obj5, _ := gabs.ParseJSON([]byte(`{"user":{"name":"dj", "hobbies": {"first": "game"}}}`))
27     arr5, _ := gabs.ParseJSON([]byte(`{"user": {"hobbies": ["programming"]}}`))
28     obj5.Merge(arr5)
29     fmt.Println(obj5.StringIndent("", "  "))
30 }

posted @ 2021-07-07 16:38 Jinxiaobo0509 阅读(407) 评论(0) 收藏举报

刷新页面返回顶部

go语言gabs库的使用

公告