garray

数组容器,提供普通数组,及排序数组,支持数据项唯一性矫正,支持并发安全开关控制。

使用场景

数组操作。

使用方式

  1. import "github.com/gogf/gf/container/garray"

接口文档

https://godoc.org/github.com/gogf/gf/container/garray

由于garray模块下的对象及方法较多,支持int/string/interface{}三种数据类型,这里便不一一列举。garray下包含了多种数据类型的slice,可以使用 garray.New*Array/garray.NewSorted*Array 方法来创建,其中garray.New*Array为普通不排序数组,garray.NewSorted*Array为排序数组(当创建interface{}类型的数组时,创建时可以指定自定义的排序函数)。

示例1,普通数组

  1. package main
  2. import (
  3. "fmt"
  4. "github.com/gogf/gf/container/garray"
  5. )
  6. func main () {
  7. // 创建并发安全的int类型数组
  8. a := garray.NewIntArray(true)
  9. // 添加数据项
  10. for i := 0; i < 10; i++ {
  11. a.Append(i)
  12. }
  13. // 获取当前数组长度
  14. fmt.Println(a.Len())
  15. // 获取当前数据项列表
  16. fmt.Println(a.Slice())
  17. // 获取指定索引项
  18. fmt.Println(a.Get(6))
  19. // 在指定索引前插入数据项
  20. a.InsertAfter(9, 11)
  21. // 在指定索引后插入数据项
  22. a.InsertBefore(10, 10)
  23. fmt.Println(a.Slice())
  24. // 修改指定索引的数据项
  25. a.Set(0, 100)
  26. fmt.Println(a.Slice())
  27. // 搜索数据项,返回搜索到的索引位置
  28. fmt.Println(a.Search(5))
  29. // 删除指定索引的数据项
  30. a.Remove(0)
  31. fmt.Println(a.Slice())
  32. // 并发安全,写锁操作
  33. a.LockFunc(func(array []int) {
  34. // 将末尾项改为100
  35. array[len(array) - 1] = 100
  36. })
  37. // 并发安全,读锁操作
  38. a.RLockFunc(func(array []int) {
  39. fmt.Println(array[len(array) - 1])
  40. })
  41. // 清空数组
  42. fmt.Println(a.Slice())
  43. a.Clear()
  44. fmt.Println(a.Slice())
  45. }

执行后,输出结果为:

  1. 10
  2. [0 1 2 3 4 5 6 7 8 9]
  3. 6 true
  4. [0 1 2 3 4 5 6 7 8 9 10 11]
  5. [100 1 2 3 4 5 6 7 8 9 10 11]
  6. 5
  7. [1 2 3 4 5 6 7 8 9 10 11]
  8. 100
  9. [1 2 3 4 5 6 7 8 9 10 100]
  10. []

示例2,排序数组

排序数组的方法与普通数组类似,但是带有自动排序功能及唯一性过滤功能。

  1. package main
  2. import (
  3. "fmt"
  4. "github.com/gogf/gf/container/garray"
  5. )
  6. func main () {
  7. // 自定义排序数组,降序排序(SortedIntArray管理的数据是升序)
  8. a := garray.NewSortedArray(func(v1, v2 interface{}) int {
  9. if v1.(int) < v2.(int) {
  10. return 1
  11. }
  12. if v1.(int) > v2.(int) {
  13. return -1
  14. }
  15. return 0
  16. })
  17. // 添加数据
  18. a.Add(2)
  19. a.Add(3)
  20. a.Add(1)
  21. fmt.Println(a.Slice())
  22. // 添加重复数据
  23. a.Add(3)
  24. fmt.Println(a.Slice())
  25. // 检索数据,返回最后对比的索引位置,检索结果
  26. // 检索结果:0: 匹配; <0:参数小于对比值; >0:参数大于对比值
  27. fmt.Println(a.Search(1))
  28. // 设置不可重复
  29. a.SetUnique(true)
  30. fmt.Println(a.Slice())
  31. a.Add(1)
  32. fmt.Println(a.Slice())
  33. }

执行后,输出结果:

  1. [3 2 1]
  2. [3 3 2 1]
  3. 3 0
  4. [3 2 1]
  5. [3 2 1]

示例3,JSON序列化/反序列

garray模块下的所有容器类型均实现了标准库json数据格式的序列化/反序列化接口。

  1. Marshal

    1. package main
    2. import (
    3. "encoding/json"
    4. "fmt"
    5. "github.com/gogf/gf/container/garray"
    6. )
    7. func main() {
    8. type Student struct {
    9. Id int
    10. Name string
    11. Scores *garray.IntArray
    12. }
    13. s := Student{
    14. Id: 1,
    15. Name: "john",
    16. Scores: garray.NewIntArrayFrom([]int{100, 99, 98}),
    17. }
    18. b, _ := json.Marshal(s)
    19. fmt.Println(string(b))
    20. }

    执行后,输出结果:

    1. {"Id":1,"Name":"john","Scores":[100,99,98]}
  2. Unmarshal

    1. package main
    2. import (
    3. "encoding/json"
    4. "fmt"
    5. "github.com/gogf/gf/container/garray"
    6. )
    7. func main() {
    8. b := []byte(`{"Id":1,"Name":"john","Scores":[100,99,98]}`)
    9. type Student struct {
    10. Id int
    11. Name string
    12. Scores *garray.IntArray
    13. }
    14. s := Student{}
    15. json.Unmarshal(b, &s)
    16. fmt.Println(s)
    17. }

    执行后,输出结果:

    1. {1 john [100,99,98]}