gset

    同时，gset支持可选的并发安全参数选项，支持并发安全的场景。

    使用场景：

    集合操作。

    使用方式：

    接口文档： https://godoc.org/github.com/gogf/gf/container/gset

    1. package main
    3. import (
    4.     "github.com/gogf/gf/container/gset"
    5.     "fmt"
    6. )
    8. func main() {
    9.     // 创建一个并发安全的集合对象
    10.     s := gset.New(true)
    12.     // 添加数据项
    13.     s.Add(1)
    15.     // 批量添加数据项
    16.     s.Add([]interface{}{1, 2, 3}...)
    18.     // 集合数据项大小
    19.     fmt.Println(s.Size())
    21.     // 集合中是否存在指定数据项
    22.     fmt.Println(s.Contains(2))
    24.     // 返回数据项slice
    25.     fmt.Println(s.Slice())
    27.     // 删除数据项
    28.     s.Remove(3)
    30.     // 遍历数据项
    31.     s.Iterator(func(v interface{}) bool {
    32.         fmt.Println("Iterator:", v)
    33.         return true
    34.     })
    36.     // 将集合转换为字符串
    37.     fmt.Println(s.String())
    39.     // 并发安全写锁操作
    40.     s.LockFunc(func(m map[interface{}]struct{}) {
    41.         m[4] = struct{}{}
    42.     })
    44.     // 并发安全读锁操作
    45.     s.RLockFunc(func(m map[interface{}]struct{}) {
    46.         fmt.Println(m)
    47.     })
    49.     // 清空集合
    50.     s.Clear()
    51.     fmt.Println(s.Size())
    52. }
    1. 3
    2. true
    3. [1 2 3]
    4. Iterator: 1
    5. Iterator: 2
    6. [1 2]
    7. map[1:{} 2:{} 4:{}]
    8. 0

    交差并补集

    我们可以使用以下方法实现交差并补集，并返回一个新的结果集合，

    1. func (set *Set) Intersect(others ...*Set) (newSet *Set)
    2. func (set *Set) Diff(others ...*Set) (newSet *Set)
    3. func (set *Set) Union(others ...*Set) (newSet *Set)
    4. func (set *Set) Complement(full *Set) (newSet *Set)
    1. Intersect: 交集，属于set且属于others的元素为元素的集合。
    2. Diff: 差集，属于set且不属于others的元素为元素的集合。
    3. Union: 并集，属于set或属于others的元素为元素的集合。
    4. Complement: 补集，(前提: set应当为full的子集)属于全集full不属于集合set的元素组成的集合。如果给定的full集合不是set的全集时，返回full与set的差集.

    通过集合方法我们可以发现，交差并集方法支持多个集合参数进行计算。以下为简化示例，只使用一个参数集合。

    1. package main
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/frame/g"
    6.     "github.com/gogf/gf/container/gset"
    7. )
    9.     s1 := gset.NewFrom(g.Slice{1, 2, 3})
    10.     s2 := gset.NewFrom(g.Slice{4, 5, 6})
    11.     s3 := gset.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7})
    13.     // 交集
    15.     // 差集
    16.     fmt.Println(s3.Diff(s1).Slice())
    17.     // 并集
    18.     fmt.Println(s1.Union(s2).Slice())
    19.     // 补集
    20.     fmt.Println(s1.Complement(s3).Slice())
    21. }

    执行后，输出结果为：

    Contains/ContainsI包含判断

    1. package main
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/container/gset"
    6. )
    8. func main() {
    9.     var set gset.StrSet
    10.     set.Add("a")
    11.     fmt.Println(set.Contains("a"))
    12.     fmt.Println(set.Contains("A"))
    13.     fmt.Println(set.ContainsI("A"))
    15.     // Output:
    16.     // true
    17.     // false
    18.     // true
    19. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/container/gset"
    6. )
    8. func main() {
    9.     var set gset.Set
    10.     set.Add(1, 2, 3, 4)
    11.     fmt.Println(set.Pop())
    12.     fmt.Println(set.Pops(2))
    13.     fmt.Println(set.Size())
    15.     // May Output:
    16.     // 1
    17.     // [2 3]
    18.     // 1
    19. }

    Join集合项串连

    1. package main
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/container/gset"
    6. )
    8. func main() {
    9.     var set gset.Set
    10.     set.Add("a", "b", "c", "d")
    11.     fmt.Println(set.Join(","))
    13.     // May Output:
    14.     // a,b,c,d
    15. }

    IsSubsetOf子集判断

    1. package main
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/container/gset"
    6.     "github.com/gogf/gf/frame/g"
    7. )
    9. func main() {
    10.     var s1, s2 gset.Set
    11.     s1.Add(g.Slice{1, 2, 3}...)
    12.     s2.Add(g.Slice{2, 3}...)
    13.     fmt.Println(s1.IsSubsetOf(&s2))
    14.     fmt.Println(s2.IsSubsetOf(&s1))
    16.     // Output:
    17.     // false
    18.     // true
    19. }

    判断性写入是指当指定的数据项不存在时则写入并且方法返回true，否则忽略吸入并且方法返回false。相关方法如下：

    • AddIfNotExist
    • AddIfNotExistFunc

    方法具体描述请查看接口文档或源码注释。

    遍历修改

    1. package main
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/container/gset"
    6.     "github.com/gogf/gf/frame/g"
    7. )
    9. func main() {
    10.     var (
    11.         set    gset.StrSet
    12.         names  = g.SliceStr{"user", "user_detail"}
    13.         prefix = "gf_"
    14.     )
    15.     set.Add(names...)
    16.     // Add prefix for given table names.
    17.     set.Walk(func(item string) string {
    18.         return prefix + item
    19.     })
    20.     fmt.Println(set.Slice())
    22.     // May Output:
    23.     // [gf_user gf_user_detail]
    24. }

    JSON序列化/反序列

    1. Marshal

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

      执行后，输出结果：

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

    2. Unmarshal

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

      执行后，输出结果：

    性能测试

    https://github.com/gogf/gf/blob/master/container/gset/gset_z_bench_test.go

    1. goos: linux
    2. goarch: amd64
    3. Benchmark_IntSet_Add-4                  10000000               277 ns/op               8 B/op          0 allocs/op
    4. Benchmark_IntSet_Contains-4             20000000              60.6 ns/op               0 B/op          0 allocs/op
    5. Benchmark_IntSet_Remove-4               10000000               211 ns/op               0 B/op          0 allocs/op
    6. Benchmark_AnySet_Add-4                   5000000               312 ns/op              21 B/op          1 allocs/op
    7. Benchmark_AnySet_Contains-4             30000000              68.2 ns/op               0 B/op          0 allocs/op
    8. Benchmark_AnySet_Remove-4                5000000               267 ns/op               0 B/op          0 allocs/op
    9. Benchmark_StrSet_Add-4                   5000000               383 ns/op              20 B/op          1 allocs/op
    10. Benchmark_StrSet_Contains-4             10000000               160 ns/op               7 B/op          0 allocs/op
    11. Benchmark_StrSet_Remove-4                5000000               306 ns/op               7 B/op          0 allocs/op
    12. Benchmark_Unsafe_IntSet_Add-4           10000000               258 ns/op              35 B/op          0 allocs/op
    13. Benchmark_Unsafe_IntSet_Contains-4      20000000               146 ns/op               0 B/op          0 allocs/op
    14. Benchmark_Unsafe_IntSet_Remove-4        10000000               173 ns/op               0 B/op          0 allocs/op
    15. Benchmark_Unsafe_AnySet_Add-4            5000000               355 ns/op              41 B/op          1 allocs/op
    16. Benchmark_Unsafe_AnySet_Contains-4      10000000               150 ns/op               0 B/op          0 allocs/op
    17. Benchmark_Unsafe_AnySet_Remove-4        200000000             11.9 ns/op               0 B/op          0 allocs/op
    18. Benchmark_Unsafe_StrSet_Add-4            5000000               486 ns/op              59 B/op          1 allocs/op