gset

Add adds one or multiple items to the set.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	intSet := gset.NewIntSetFrom([]int{1, 2, 3})
	intSet.Add(1)
	fmt.Println(intSet.Slice())
	fmt.Println(intSet.AddIfNotExist(1))

	// May Output:
	// [1 2 3]
	// false
}

Output:

AddIfNotExist checks whether item exists in the set, it adds the item to set and returns true if it does not exists in the set, or else it does nothing and returns false.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	intSet := gset.NewIntSetFrom([]int{1, 2, 3})
	intSet.Add(1)
	fmt.Println(intSet.Slice())
	fmt.Println(intSet.AddIfNotExist(1))

	// May Output:
	// [1 2 3]
	// false
}

Output:

AddIfNotExistFunc checks whether item exists in the set, it adds the item to set and returns true if it does not exists in the set and function `f` returns true, or else it does nothing and returns false. Note that, the function `f` is executed without writing lock.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	intSet := gset.NewIntSetFrom([]int{1, 2, 3})
	intSet.Add(1)
	fmt.Println(intSet.Slice())
	fmt.Println(intSet.AddIfNotExistFunc(5, func() bool {
		return true
	}))

	// May Output:
	// [1 2 3]
	// true
}

Output:

AddIfNotExistFunc checks whether item exists in the set, it adds the item to set and returns true if it does not exists in the set and function `f` returns true, or else it does nothing and returns false. Note that, the function `f` is executed without writing lock.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	intSet := gset.NewIntSetFrom([]int{1, 2, 3})
	intSet.Add(1)
	fmt.Println(intSet.Slice())
	fmt.Println(intSet.AddIfNotExistFuncLock(4, func() bool {
		return true
	}))

	// May Output:
	// [1 2 3]
	// true
}

Output:

Clear deletes all items of the set.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	intSet := gset.NewIntSetFrom([]int{1, 2, 3})
	fmt.Println(intSet.Size())
	intSet.Clear()
	fmt.Println(intSet.Size())

}

Output:

3
0

Complement returns a new set which is the complement from `set` to `full`. Which means, all the items in `newSet` are in `full` and not in `set`. It returns the difference between `full` and `set` if the given set `full` is not the full set of `set`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	intSet := gset.NewIntSetFrom([]int{1, 2, 3, 4, 5})
	s := gset.NewIntSetFrom([]int{1, 2, 3})
	fmt.Println(s.Complement(intSet).Slice())

	// May Output:
	// [4 5]
}

Output:

Contains checks whether the set contains `item`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	var set1 gset.IntSet
	set1.Add(1, 4, 5, 6, 7)
	fmt.Println(set1.Contains(1))

	var set2 gset.IntSet
	set2.Add(1, 4, 5, 6, 7)
	fmt.Println(set2.Contains(8))

}

Output:

true
false

Diff returns a new set which is the difference set from `set` to `other`. Which means, all the items in `newSet` are in `set` but not in `other`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSetFrom([]int{1, 2, 3})
	s2 := gset.NewIntSetFrom([]int{1, 2, 3, 4})
	fmt.Println(s2.Diff(s1).Slice())

}

Output:

[4]

Equal checks whether the two sets equal.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSetFrom([]int{1, 2, 3})
	s2 := gset.NewIntSetFrom([]int{1, 2, 3, 4})
	fmt.Println(s2.Equal(s1))

	s3 := gset.NewIntSetFrom([]int{1, 2, 3})
	s4 := gset.NewIntSetFrom([]int{1, 2, 3})
	fmt.Println(s3.Equal(s4))

}

Output:

false
true

Intersect returns a new set which is the intersection from `set` to `other`. Which means, all the items in `newSet` are in `set` and also in `other`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3}...)
	var s2 gset.IntSet
	s2.Add([]int{1, 2, 3, 4}...)
	fmt.Println(s2.Intersect(s1).Slice())

	// May Output:
	// [1 2 3]
}

Output:

IsSubsetOf checks whether the current set is a sub-set of `other`

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	var s2 gset.IntSet
	s2.Add([]int{1, 2, 4}...)
	fmt.Println(s2.IsSubsetOf(s1))

}

Output:

true

Iterator iterates the set readonly with given callback function `f`, if `f` returns true then continue iterating; or false to stop.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	s1.Iterator(func(v int) bool {
		fmt.Println("Iterator", v)
		return true
	})
	// May Output:
	// Iterator 2
	// Iterator 3
	// Iterator 1
	// Iterator 4
}

Output:

Join joins items with a string `glue`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	fmt.Println(s1.Join(","))

	// May Output:
	// 3,4,1,2
}

Output:

LockFunc locks writing with callback function `f`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2}...)
	s1.LockFunc(func(m map[int]struct{}) {
		m[3] = struct{}{}
	})
	fmt.Println(s1.Slice())

	// May Output
	// [2 3 1]
}

Output:

MarshalJSON implements the interface MarshalJSON for json.Marshal.

package main

import (
	"encoding/json"
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	type Student struct {
		Id     int
		Name   string
		Scores *gset.IntSet
	}
	s := Student{
		Id:     1,
		Name:   "john",
		Scores: gset.NewIntSetFrom([]int{100, 99, 98}),
	}
	b, _ := json.Marshal(s)
	fmt.Println(string(b))

	// May Output:
	// {"Id":1,"Name":"john","Scores":[100,99,98]}
}

Output:

Merge adds items from `others` sets into `set`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)

	s2 := gset.NewIntSet()
	fmt.Println(s1.Merge(s2).Slice())

	// May Output:
	// [1 2 3 4]
}

Output:

Pops randomly pops an item from set.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)

	fmt.Println(s1.Pop())

	// May Output:
	// 1
}

Output:

Pops randomly pops `size` items from set. It returns all items if size == -1.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	for _, v := range s1.Pops(2) {
		fmt.Println(v)
	}

	// May Output:
	// 1
	// 2
}

Output:

RLockFunc locks reading with callback function `f`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	s1.RLockFunc(func(m map[int]struct{}) {
		fmt.Println(m)
	})

}

Output:

map[1:{} 2:{} 3:{} 4:{}]

Remove deletes `item` from set.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	s1.Remove(1)
	fmt.Println(s1.Slice())

	// May Output:
	// [3 4 2]
}

Output:

Size returns the size of the set.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	fmt.Println(s1.Size())

}

Output:

4

Slice returns the an of items of the set as slice.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	fmt.Println(s1.Slice())

	// May Output:
	// [1, 2, 3, 4]
}

Output:

String returns items as a string, which implements like json.Marshal does.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	fmt.Println(s1.String())

	// May Output:
	// [1,2,3,4]
}

Output:

Sum sums items. Note: The items should be converted to int type, or you'd get a result that you unexpected.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	fmt.Println(s1.Sum())

}

Output:

10

Union returns a new set which is the union of `set` and `other`. Which means, all the items in `newSet` are in `set` or in `other`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	s2 := gset.NewIntSet()
	s2.Add([]int{1, 2, 4}...)
	fmt.Println(s1.Union(s2).Slice())

	// May Output:
	// [3 4 1 2]
}

Output:

UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

package main

import (
	"encoding/json"
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	b := []byte(`{"Id":1,"Name":"john","Scores":[100,99,98]}`)
	type Student struct {
		Id     int
		Name   string
		Scores *gset.IntSet
	}
	s := Student{}
	json.Unmarshal(b, &s)
	fmt.Println(s)

	// May Output:
	// {1 john [100,99,98]}
}

Output:

UnmarshalValue is an interface implement which sets any type of value for set.

package main

import (
	"encoding/json"
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	b := []byte(`{"Id":1,"Name":"john","Scores":100,99,98}`)
	type Student struct {
		Id     int
		Name   string
		Scores *gset.IntSet
	}
	s := Student{}
	json.Unmarshal(b, &s)
	fmt.Println(s)

	// May Output:
	// {1 john [100,99,98]}
}

Output:

Walk applies a user supplied function `f` to every item of set.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
	"github.com/gogf/gf/v2/frame/g"
)

func main() {
	var (
		set   gset.IntSet
		names = g.SliceInt{1, 0}
		delta = 10
	)
	set.Add(names...)
	// Add prefix for given table names.
	set.Walk(func(item int) int {
		return delta + item
	})
	fmt.Println(set.Slice())

	// May Output:
	// [12 60]
}

Output:

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	var set gset.Set
	fmt.Println(set.AddIfNotExist(1))
	fmt.Println(set.AddIfNotExist(1))
	fmt.Println(set.Slice())

}

Output:

true
false
[1]

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
	"github.com/gogf/gf/v2/frame/g"
)

func main() {
	s1 := gset.NewFrom(g.Slice{1, 2, 3})
	s2 := gset.NewFrom(g.Slice{4, 5, 6})
	s3 := gset.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7})

	fmt.Println(s3.Intersect(s1).Slice())
	fmt.Println(s3.Diff(s1).Slice())
	fmt.Println(s1.Union(s2).Slice())
	fmt.Println(s1.Complement(s3).Slice())

	// May Output:
	// [2 3 1]
	// [5 6 7 4]
	// [6 1 2 3 4 5]
	// [4 5 6 7]
}

Output:

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	var set gset.StrSet
	set.Add("a")
	fmt.Println(set.Contains("a"))
	fmt.Println(set.Contains("A"))
	fmt.Println(set.ContainsI("A"))

}

Output:

true
false
true

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
	"github.com/gogf/gf/v2/frame/g"
)

func main() {
	s1 := gset.NewFrom(g.Slice{1, 2, 3})
	s2 := gset.NewFrom(g.Slice{4, 5, 6})
	s3 := gset.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7})

	fmt.Println(s3.Intersect(s1).Slice())
	fmt.Println(s3.Diff(s1).Slice())
	fmt.Println(s1.Union(s2).Slice())
	fmt.Println(s1.Complement(s3).Slice())

	// May Output:
	// [2 3 1]
	// [5 6 7 4]
	// [6 1 2 3 4 5]
	// [4 5 6 7]
}

Output:

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
	"github.com/gogf/gf/v2/frame/g"
)

func main() {
	s1 := gset.NewFrom(g.Slice{1, 2, 3})
	s2 := gset.NewFrom(g.Slice{4, 5, 6})
	s3 := gset.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7})

	fmt.Println(s3.Intersect(s1).Slice())
	fmt.Println(s3.Diff(s1).Slice())
	fmt.Println(s1.Union(s2).Slice())
	fmt.Println(s1.Complement(s3).Slice())

	// May Output:
	// [2 3 1]
	// [5 6 7 4]
	// [6 1 2 3 4 5]
	// [4 5 6 7]
}

Output:

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
	"github.com/gogf/gf/v2/frame/g"
)

func main() {
	var s1, s2 gset.Set
	s1.Add(g.Slice{1, 2, 3}...)
	s2.Add(g.Slice{2, 3}...)
	fmt.Println(s1.IsSubsetOf(&s2))
	fmt.Println(s2.IsSubsetOf(&s1))

}

Output:

false
true

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	var set gset.Set
	set.Add("a", "b", "c", "d")
	fmt.Println(set.Join(","))

	// May Output:
	// a,b,c,d
}

Output:

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	var set gset.Set
	set.Add(1, 2, 3, 4)
	fmt.Println(set.Pop())
	fmt.Println(set.Pops(2))
	fmt.Println(set.Size())

	// May Output:
	// 1
	// [2 3]
	// 1
}

Output:

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	var set gset.Set
	set.Add(1, 2, 3, 4)
	fmt.Println(set.Pop())
	fmt.Println(set.Pops(2))
	fmt.Println(set.Size())

	// May Output:
	// 1
	// [2 3]
	// 1
}

Output:

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
	"github.com/gogf/gf/v2/frame/g"
)

func main() {
	s1 := gset.NewFrom(g.Slice{1, 2, 3})
	s2 := gset.NewFrom(g.Slice{4, 5, 6})
	s3 := gset.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7})

	fmt.Println(s3.Intersect(s1).Slice())
	fmt.Println(s3.Diff(s1).Slice())
	fmt.Println(s1.Union(s2).Slice())
	fmt.Println(s1.Complement(s3).Slice())

	// May Output:
	// [2 3 1]
	// [5 6 7 4]
	// [6 1 2 3 4 5]
	// [4 5 6 7]
}

Output:

Add adds one or multiple items to the set.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSetFrom([]string{"str1", "str2", "str3"}, true)
	strSet.Add("str")
	fmt.Println(strSet.Slice())
	fmt.Println(strSet.AddIfNotExist("str"))

	// May Output:
	// [str str1 str2 str3]
	// false
}

Output:

AddIfNotExist checks whether item exists in the set, it adds the item to set and returns true if it does not exist in the set, or else it does nothing and returns false.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSetFrom([]string{"str1", "str2", "str3"}, true)
	strSet.Add("str")
	fmt.Println(strSet.Slice())
	fmt.Println(strSet.AddIfNotExist("str"))

	// May Output:
	// [str str1 str2 str3]
	// false
}

Output:

AddIfNotExistFunc checks whether item exists in the set, it adds the item to set and returns true if it does not exist in the set and function `f` returns true, or else it does nothing and returns false. Note that, the function `f` is executed without writing lock.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSetFrom([]string{"str1", "str2", "str3"}, true)
	strSet.Add("str")
	fmt.Println(strSet.Slice())
	fmt.Println(strSet.AddIfNotExistFunc("str5", func() bool {
		return true
	}))

	// May Output:
	// [str1 str2 str3 str]
	// true
}

Output:

AddIfNotExistFunc checks whether item exists in the set, it adds the item to set and returns true if it does not exist in the set and function `f` returns true, or else it does nothing and returns false. Note that, the function `f` is executed without writing lock.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSetFrom([]string{"str1", "str2", "str3"}, true)
	strSet.Add("str")
	fmt.Println(strSet.Slice())
	fmt.Println(strSet.AddIfNotExistFuncLock("str4", func() bool {
		return true
	}))

	// May Output:
	// [str1 str2 str3 str]
	// true
}

Output:

Clear deletes all items of the set.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSetFrom([]string{"str1", "str2", "str3"}, true)
	fmt.Println(strSet.Size())
	strSet.Clear()
	fmt.Println(strSet.Size())

}

Output:

3
0

Complement returns a new set which is the complement from `set` to `full`. Which means, all the items in `newSet` are in `full` and not in `set`. It returns the difference between `full` and `set` if the given set `full` is not the full set of `set`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSetFrom([]string{"str1", "str2", "str3", "str4", "str5"}, true)
	s := gset.NewStrSetFrom([]string{"str1", "str2", "str3"}, true)
	fmt.Println(s.Complement(strSet).Slice())

	// May Output:
	// [str4 str5]
}

Output:

Contains checks whether the set contains `item`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	var set gset.StrSet
	set.Add("a")
	fmt.Println(set.Contains("a"))
	fmt.Println(set.Contains("A"))

}

Output:

true
false

ContainsI checks whether a value exists in the set with case-insensitively. Note that it internally iterates the whole set to do the comparison with case-insensitively.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	var set gset.StrSet
	set.Add("a")
	fmt.Println(set.ContainsI("a"))
	fmt.Println(set.ContainsI("A"))

}

Output:

true
true

Diff returns a new set which is the difference set from `set` to `other`. Which means, all the items in `newSet` are in `set` but not in `other`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSetFrom([]string{"a", "b", "c"}, true)
	s2 := gset.NewStrSetFrom([]string{"a", "b", "c", "d"}, true)
	fmt.Println(s2.Diff(s1).Slice())

}

Output:

[d]

Equal checks whether the two sets equal.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSetFrom([]string{"a", "b", "c"}, true)
	s2 := gset.NewStrSetFrom([]string{"a", "b", "c", "d"}, true)
	fmt.Println(s2.Equal(s1))

	s3 := gset.NewStrSetFrom([]string{"a", "b", "c"}, true)
	s4 := gset.NewStrSetFrom([]string{"a", "b", "c"}, true)
	fmt.Println(s3.Equal(s4))

}

Output:

false
true

Intersect returns a new set which is the intersection from `set` to `other`. Which means, all the items in `newSet` are in `set` and also in `other`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c"}...)
	var s2 gset.StrSet
	s2.Add([]string{"a", "b", "c", "d"}...)
	fmt.Println(s2.Intersect(s1).Slice())

	// May Output:
	// [c a b]
}

Output:

IsSubsetOf checks whether the current set is a sub-set of `other`

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	var s2 gset.StrSet
	s2.Add([]string{"a", "b", "d"}...)
	fmt.Println(s2.IsSubsetOf(s1))

}

Output:

true

Iterator iterates the set readonly with given callback function `f`, if `f` returns true then continue iterating; or false to stop.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	s1.Iterator(func(v string) bool {
		fmt.Println("Iterator", v)
		return true
	})

	// May Output:
	// Iterator a
	// Iterator b
	// Iterator c
	// Iterator d
}

Output:

Join joins items with a string `glue`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	fmt.Println(s1.Join(","))

	// May Output:
	// b,c,d,a
}

Output:

LockFunc locks writing with callback function `f`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"1", "2"}...)
	s1.LockFunc(func(m map[string]struct{}) {
		m["3"] = struct{}{}
	})
	fmt.Println(s1.Slice())

	// May Output
	// [2 3 1]

}

Output:

MarshalJSON implements the interface MarshalJSON for json.Marshal.

package main

import (
	"encoding/json"
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	type Student struct {
		Id     int
		Name   string
		Scores *gset.StrSet
	}
	s := Student{
		Id:     1,
		Name:   "john",
		Scores: gset.NewStrSetFrom([]string{"100", "99", "98"}, true),
	}
	b, _ := json.Marshal(s)
	fmt.Println(string(b))

	// May Output:
	// {"Id":1,"Name":"john","Scores":["100","99","98"]}
}

Output:

Merge adds items from `others` sets into `set`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)

	s2 := gset.NewStrSet(true)
	fmt.Println(s1.Merge(s2).Slice())

	// May Output:
	// [d a b c]
}

Output:

Pops randomly pops an item from set.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)

	fmt.Println(s1.Pop())

	// May Output:
	// a
}

Output:

Pops randomly pops `size` items from set. It returns all items if size == -1.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	for _, v := range s1.Pops(2) {
		fmt.Println(v)
	}

	// May Output:
	// a
	// b
}

Output:

RLockFunc locks reading with callback function `f`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	s1.RLockFunc(func(m map[string]struct{}) {
		fmt.Println(m)
	})

}

Output:

map[a:{} b:{} c:{} d:{}]

Remove deletes `item` from set.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	s1.Remove("a")
	fmt.Println(s1.Slice())

	// May Output:
	// [b c d]
}

Output:

Size returns the size of the set.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	fmt.Println(s1.Size())

}

Output:

4

Slice returns the an of items of the set as slice.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	fmt.Println(s1.Slice())

	// May Output:
	// [a,b,c,d]
}

Output:

String returns items as a string, which implements like json.Marshal does.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	fmt.Println(s1.String())

	// May Output:
	// "a","b","c","d"
}

Output:

Sum sums items. Note: The items should be converted to int type, or you'd get a result that you unexpected.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"1", "2", "3", "4"}...)
	fmt.Println(s1.Sum())

}

Output:

10

Union returns a new set which is the union of `set` and `other`. Which means, all the items in `newSet` are in `set` or in `other`.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	s2 := gset.NewStrSet(true)
	s2.Add([]string{"a", "b", "d"}...)
	fmt.Println(s1.Union(s2).Slice())

	// May Output:
	// [a b c d]
}

Output:

UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

package main

import (
	"encoding/json"
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	b := []byte(`{"Id":1,"Name":"john","Scores":["100","99","98"]}`)
	type Student struct {
		Id     int
		Name   string
		Scores *gset.StrSet
	}
	s := Student{}
	json.Unmarshal(b, &s)
	fmt.Println(s)

	// May Output:
	// {1 john "99","98","100"}
}

Output:

UnmarshalValue is an interface implement which sets any type of value for set.

package main

import (
	"encoding/json"
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
)

func main() {
	b := []byte(`{"Id":1,"Name":"john","Scores":["100","99","98"]}`)
	type Student struct {
		Id     int
		Name   string
		Scores *gset.StrSet
	}
	s := Student{}
	json.Unmarshal(b, &s)
	fmt.Println(s)

	// May Output:
	// {1 john "99","98","100"}
}

Output:

Walk applies a user supplied function `f` to every item of set.

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gset"
	"github.com/gogf/gf/v2/frame/g"
)

func main() {
	var (
		set    gset.StrSet
		names  = g.SliceStr{"user", "user_detail"}
		prefix = "gf_"
	)
	set.Add(names...)
	// Add prefix for given table names.
	set.Walk(func(item string) string {
		return prefix + item
	})
	fmt.Println(set.Slice())

	// May Output:
	// [gf_user gf_user_detail]
}

Output: