• garray
    • 使用示例1，普通数组
    • 使用示例2，排序数组

    garray

    数组容器，提供普通数组，及排序数组，支持数据项唯一性矫正，支持可选的并发安全参数控制。

    使用场景：

    数组操作。

    使用方式：

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

    接口文档：

    https://godoc.org/github.com/gogf/gf/g/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
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/g/container/garray"
    6. )
    9. func main () {
    10.     // 创建普通的int类型数组，并关闭默认的并发安全特性
    11.     a := garray.NewIntArray(true)
    13.     // 添加数据项
    14.     for i := 0; i < 10; i++ {
    15.         a.Append(i)
    16.     }
    18.     // 获取当前数组长度
    19.     fmt.Println(a.Len())
    21.     // 获取当前数据项列表
    22.     fmt.Println(a.Slice())
    24.     // 获取指定索引项
    25.     fmt.Println(a.Get(6))
    27.     // 在指定索引前插入数据项
    28.     a.InsertAfter(9, 11)
    29.     // 在指定索引后插入数据项
    30.     a.InsertBefore(10, 10)
    31.     fmt.Println(a.Slice())
    33.     // 修改指定索引的数据项
    34.     a.Set(0, 100)
    35.     fmt.Println(a.Slice())
    37.     // 搜索数据项，返回搜索到的索引位置
    38.     fmt.Println(a.Search(5))
    40.     // 删除指定索引的数据项
    41.     a.Remove(0)
    42.     fmt.Println(a.Slice())
    44.     // 并发安全，写锁操作
    45.     a.LockFunc(func(array []int) {
    46.         // 将末尾项改为100
    47.         array[len(array) - 1] = 100
    48.     })
    50.     // 并发安全，读锁操作
    51.     a.RLockFunc(func(array []int) {
    52.         fmt.Println(array[len(array) - 1])
    53.     })
    55.     // 清空数组
    56.     fmt.Println(a.Slice())
    57.     a.Clear()
    58.     fmt.Println(a.Slice())
    59. }

    执行后，输出结果为：

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

    执行后，输出结果：

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