数组|散列

操作切片

判断切片中是否存在指定值

func Contains(collection []T, v T) bool


d := []int{1,2,3}
v := zarray.Contains(d, 2) // true

返回两个切片中的差异

func Diff(list1 []T, list2 []T) ([]T, []T)


a := []int{1, 2, 3, 4}
b := []int{2, 3, 5}
onlyA, onlyB := zarray.Diff(a, b) // onlyA: [1,4], onlyB: [5]

返回两个切片的交集

func Intersection[T comparable](list1 []T, list2 []T) []T


a := []int{1, 2, 3}
b := []int{2, 3, 4}
result := zarray.Intersection(a, b) // [2, 3]

对切片进行优先级排序

func SortWithPriority[T comparable](slice []T, first, last []T) []T


data := []int{1, 2, 3, 4, 5}
first := []int{5, 3}
last := []int{4}
result := zarray.SortWithPriority(data, first, last) // [5, 3, 1, 2, 4]

过滤切片

func Filter(slice []T, predicate func(index int, item T) bool) []T


data := []int{1, 2, 3, 4, 5}
result := zarray.Filter(data, func(i, v int) bool {
    return v%2 == 0
}) // [2, 4]

查询第一个匹配的切片元素

func Find(collection []T, predicate func(index int, item T) bool) (T, bool)


data := []string{"a", "b", "c"}
v, found := zarray.Find(data, func(i int, s string) bool {
    return s == "b"
}) // "b", true

从切片中随机取一个值

func Rand(collection []T) T


data := []int{1, 2, 3, 4, 5}
v := zarray.Rand(data) // 随机返回一个元素

从切片中随机取 N 个值

func RandPickN[T any](collection []T, n int) []T


data := []int{1, 2, 3, 4, 5}
result := zarray.RandPickN(data, 3) // 返回3个随机元素

打乱切片

func Shuffle(collection []T) []T


data := []int{1, 2, 3, 4, 5}
result := zarray.Shuffle(data) // 返回打乱顺序的切片

切片去重

func Unique(collection []T) []T


data := []int{1, 2, 2, 3, 3, 3}
result := zarray.Unique(data) // [1, 2, 3]

切片分段

func Chunk[T any](slice []T, size int) [][]T


data := []int{1, 2, 3, 4, 5}
result := zarray.Chunk(data, 2) // [[1, 2], [3, 4], [5]]

遍历切片返回一个新的切片

func Map(collection []T, iteratee func(int, *T) R) []R


data := []int{1, 2, 3}
result := zarray.Map(data, func(i int, v *int) int {
    return *v * 2
}) // [2, 4, 6]

切割字符串

注意会去掉前后空格

func Slice[T comparable](s string, n ...int) []T


s := "1, 2, 3, 4"
result := zarray.Slice[int](s) // [1, 2, 3, 4]

合并数组成字符串

注意会忽略空格

func Join[T comparable](s []T, sep string) string


data := []int{1, 2, 3, 4}
result := zarray.Join(data, ",") // "1,2,3,4"

操作 Map

获取 Map 的全部 key 切片

func Keys(in map[K]V) []K


m := map[string]int{"a": 1, "b": 2, "c": 3}
keys := zarray.Keys(m) // ["a", "b", "c"]

获取 Map 的全部值切片

func Values(in map[K]V) []V


m := map[string]int{"a": 1, "b": 2, "c": 3}
values := zarray.Values(m) // [1, 2, 3]

将切片组合成一个 Map

func GroupMap[K comparable, V any](arr []V, toKey func(V) (K, V)) map[K]V


type User struct {
    ID   int
    Name string
}

users := []User{{1, "张三"}, {2, "李四"}, {3, "王五"}}
result := zarray.GroupMap(users, func(u User) (int, User) {
    return u.ID, u
}) // map[1:{1 张三} 2:{2 李四} 3:{3 王五}]

将 Maps 扁平化为切片

func FlatMap[K comparable, V any](m map[K]V, fn func(key K, value V) V) []V


m := map[string]int{"a": 1, "b": 2, "c": 3}
result := zarray.FlatMap(m, func(k string, v int) int {
    return v * 2
}) // [2, 4, 6]

HashMap

并发安全，泛型，只支持 Go1.18 及以上


import (
	"github.com/sohaha/zlsgo/zarray"
)

m := zarray.NewHashMap[int, string]()

// 设置
m.Set(1,"1")

// 获取
v, ok := m.Get(1)

// 获取，不存在则设置
v, ok := m.ProvideGet(1, func() (string, bool) {
    return "99", true
})

// 删除
m.Delete(1)

// 获取全部 Key
m.Keys()

// 获取全部值
m.Value()