slice

func Chunk ¶

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

Chunk

As a example:

arr := []int{1,2,3}
newArr := Chunk(arr, 2)

func Contains ¶

func Contains[T any](arr []T, f func(t T, i int) bool) bool

Contains

arr := []int{1,2,3}
b := Contains(arr, 1)
Output: true

func Diff ¶

func Diff[T comparable](arr1 []T, arr2 []T) []T

Diff

arr := []string{"1", "3", "5"}
arr2 := []string{"2", "4", "5"}
diffArr := Diff(arr, arr2)
//Output: ["1", "3", "2", "4"]

func DiffBy ¶

func DiffBy[T comparable](arr, arr2 []T, f func(a, b T) bool) []T

DiffBy

a1 := []string{"1", "3", "5"}
a2 := []string{"5", "7", "9"}
diff := slice.DiffBy(a1, a2, func(a, b string) bool {
	return a == b
})
//Output: ["1", "3", "7", "9"]

func Each ¶

func Each[T any](arr []T, f func(it T, idx int))

func EachAsync ¶

func EachAsync[T any](arr []T, f func(it T, idx int) error) error

func Filter ¶

func Filter[T any](arr []T, f func(t T, i int) bool) []T

func Find ¶

func Find[T any](arr []T, f func(t T, i int) bool) (it *T, ok bool)

func GroupBy ¶ added in v0.0.7

func GroupBy[T any, V comparable](arr []T, fn Identity[T, V]) map[V][]T

GroupBy

arr := []float64{1.1, 1.2, 2.1, 2.2}
var groupbyFn = func(f float64) int64 {
	return int64(f)
}
ret := slice.GroupBy(arr, groupbyFn)
fmt.Println(ret)
// Output: 1:1.1,1.2 2:2.1,2.2

func Map ¶

func Map[T any, V any](arr []T, f func(T, int) V) []V

func MapAsync ¶

func MapAsync[T any, V any](arr []T, f func(T, int) (V, error)) ([]V, error)

func OrderBy ¶

func OrderBy[T any](items []T, fn CompareFn[T]) []T

func Uniq ¶

func Uniq[T comparable](arr []T) []T

func UniqBy ¶

func UniqBy[T any, V comparable](arr []T, identity Identity[T, V]) []T