Documentation ¶
Overview ¶
Package slice implements some functions to manipulate slice.
Index ¶
- func AppendIfAbsent[T comparable](slice []T, item T) []T
- func Chunk[T any](slice []T, size int) [][]T
- func Compact[T comparable](slice []T) []T
- func Concat[T any](slice []T, slices ...[]T) []T
- func Contain[T comparable](slice []T, target T) bool
- func ContainSubSlice[T comparable](slice, subSlice []T) bool
- func Count[T comparable](slice []T, item T) int
- func CountBy[T any](slice []T, predicate func(index int, item T) bool) int
- func DeleteAt[T any](slice []T, start int, end ...int) []T
- func Difference[T comparable](slice, comparedSlice []T) []T
- func DifferenceBy[T comparable](slice []T, comparedSlice []T, iteratee func(index int, item T) T) []T
- func DifferenceWith[T any](slice []T, comparedSlice []T, comparator func(item1, item2 T) bool) []T
- func Drop[T any](slice []T, n int) []T
- func Equal[T comparable](slice1, slice2 []T) bool
- func EqualWith[T, U any](slice1 []T, slice2 []U, comparator func(T, U) bool) bool
- func Every[T any](slice []T, predicate func(index int, item T) bool) bool
- func Filter[T any](slice []T, predicate func(index int, item T) bool) []T
- func Find[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
- func FindLast[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
- func Flatten(slice any) any
- func FlattenDeep(slice any) any
- func ForEach[T any](slice []T, iteratee func(index int, item T))
- func GroupBy[T any](slice []T, groupFn func(index int, item T) bool) ([]T, []T)
- func GroupWith[T any, U comparable](slice []T, iteratee func(item T) U) map[U][]T
- func IndexOf[T comparable](arr []T, val T) int
- func InsertAt[T any](slice []T, index int, value any) []T
- func IntSlice(slice any) []int
- func InterfaceSlice(slice any) []any
- func Intersection[T comparable](slices ...[]T) []T
- func KeyBy[T any, U comparable](slice []T, iteratee func(item T) U) map[U]T
- func LastIndexOf[T comparable](slice []T, item T) int
- func Map[T any, U any](slice []T, iteratee func(index int, item T) U) []U
- func Merge[T any](slices ...[]T) []T
- func None[T any](slice []T, predicate func(index int, item T) bool) bool
- func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initial T) T
- func Repeat[T any](item T, n int) []T
- func Replace[T comparable](slice []T, old T, new T, n int) []T
- func ReplaceAll[T comparable](slice []T, old T, new T) []T
- func Reverse[T any](slice []T)
- func Shuffle[T any](slice []T) []T
- func Some[T any](slice []T, predicate func(index int, item T) bool) bool
- func Sort[T constraints.Ordered](slice []T, sortOrder ...string)
- func SortBy[T any](slice []T, less func(a, b T) bool)
- func SortByField(slice any, field string, sortType ...string) error
- func StringSlice(slice any) []string
- func SymmetricDifference[T comparable](slices ...[]T) []T
- func ToSlice[T any](items ...T) []T
- func ToSlicePointer[T any](items ...T) []*T
- func Union[T comparable](slices ...[]T) []T
- func UnionBy[T any, V comparable](predicate func(item T) V, slices ...[]T) []T
- func Unique[T comparable](slice []T) []T
- func UniqueBy[T comparable](slice []T, iteratee func(item T) T) []T
- func UpdateAt[T any](slice []T, index int, value T) []T
- func Without[T comparable](slice []T, items ...T) []T
Examples ¶
- AppendIfAbsent
- Chunk
- Compact
- Concat
- Contain
- ContainSubSlice
- Count
- CountBy
- DeleteAt
- Difference
- DifferenceBy
- DifferenceWith
- Drop
- Equal
- EqualWith
- Every
- Filter
- Find
- FindLast
- Flatten
- FlattenDeep
- ForEach
- GroupBy
- GroupWith
- IndexOf
- InsertAt
- IntSlice
- InterfaceSlice
- Intersection
- KeyBy
- LastIndexOf
- Map
- Merge
- None
- Reduce
- Repeat
- Replace
- ReplaceAll
- Reverse
- Some
- Sort
- SortBy
- SortByField
- StringSlice
- SymmetricDifference
- ToSlice
- ToSlicePointer
- Union
- UnionBy
- Unique
- UniqueBy
- UpdateAt
- Without
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func AppendIfAbsent ¶
func AppendIfAbsent[T comparable](slice []T, item T) []T
AppendIfAbsent only absent append the item. Play: https://golang.ir/play/p/KcC1QXQ-RkL
Example ¶
result1 := AppendIfAbsent([]string{"a", "b"}, "b") result2 := AppendIfAbsent([]string{"a", "b"}, "c") fmt.Println(result1) fmt.Println(result2)
Output: [a b] [a b c]
func Chunk ¶
Chunk creates a slice of elements split into groups the length of size. Play: https://golang.ir/play/p/b4Pou5j2L_C
Example ¶
arr := []string{"a", "b", "c", "d", "e"} result1 := Chunk(arr, 1) result2 := Chunk(arr, 2) result3 := Chunk(arr, 3) result4 := Chunk(arr, 4) result5 := Chunk(arr, 5) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) fmt.Println(result4) fmt.Println(result5)
Output: [[a] [b] [c] [d] [e]] [[a b] [c d] [e]] [[a b c] [d e]] [[a b c d] [e]] [[a b c d e]]
func Compact ¶
func Compact[T comparable](slice []T) []T
Compact creates an slice with all falsey values removed. The values false, nil, 0, and "" are falsey. Play: https://golang.ir/play/p/pO5AnxEr3TK
Example ¶
result1 := Compact([]int{0}) result2 := Compact([]int{0, 1, 2, 3}) result3 := Compact([]string{"", "a", "b", "0"}) result4 := Compact([]bool{false, true, true}) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) fmt.Println(result4)
Output: [] [1 2 3] [a b 0] [true true]
func Concat ¶
func Concat[T any](slice []T, slices ...[]T) []T
Concat creates a new slice concatenating slice with any additional slices. Play: https://golang.ir/play/p/gPt-q7zr5mk
Example ¶
result1 := Concat([]int{1, 2}, []int{3, 4}) result2 := Concat([]string{"a", "b"}, []string{"c"}, []string{"d"}) fmt.Println(result1) fmt.Println(result2)
Output: [1 2 3 4] [a b c d]
func Contain ¶
func Contain[T comparable](slice []T, target T) bool
Contain check if the target value is in the slice or not. Play: https://golang.ir/play/p/_454yEHcNjf
Example ¶
result1 := Contain([]string{"a", "b", "c"}, "a") result2 := Contain([]int{1, 2, 3}, 4) fmt.Println(result1) fmt.Println(result2)
Output: true false
func ContainSubSlice ¶
func ContainSubSlice[T comparable](slice, subSlice []T) bool
ContainSubSlice check if the slice contain a given subslice or not. Play: https://golang.ir/play/p/bcuQ3UT6Sev
Example ¶
result1 := ContainSubSlice([]string{"a", "b", "c"}, []string{"a", "b"}) result2 := ContainSubSlice([]string{"a", "b", "c"}, []string{"a", "d"}) fmt.Println(result1) fmt.Println(result2)
Output: true false
func Count ¶
func Count[T comparable](slice []T, item T) int
Count returns the number of occurrences of the given item in the slice. Play: https://golang.ir/play/p/Mj4oiEnQvRJ
Example ¶
nums := []int{1, 2, 3, 3, 4} result1 := Count(nums, 1) result2 := Count(nums, 3) fmt.Println(result1) fmt.Println(result2)
Output: 1 2
func CountBy ¶
CountBy iterates over elements of slice with predicate function, returns the number of all matched elements. Play: https://golang.ir/play/p/tHOccTMDZCC
Example ¶
nums := []int{1, 2, 3, 4, 5} isEven := func(i, num int) bool { return num%2 == 0 } result := CountBy(nums, isEven) fmt.Println(result)
Output: 2
func DeleteAt ¶
DeleteAt delete the element of slice from start index to end index - 1. Play: https://golang.ir/play/p/pJ-d6MUWcvK
Example ¶
result1 := DeleteAt([]string{"a", "b", "c"}, -1) result2 := DeleteAt([]string{"a", "b", "c"}, 0) result3 := DeleteAt([]string{"a", "b", "c"}, 0, 2) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3)
Output: [a b c] [b c] [c]
func Difference ¶
func Difference[T comparable](slice, comparedSlice []T) []T
Difference creates an slice of whose element in slice but not in comparedSlice. Play: https://golang.ir/play/p/VXvadzLzhDa
Example ¶
slice1 := []int{1, 2, 3, 4, 5} slice2 := []int{4, 5, 6} result := Difference(slice1, slice2) fmt.Println(result)
Output: [1 2 3]
func DifferenceBy ¶
func DifferenceBy[T comparable](slice []T, comparedSlice []T, iteratee func(index int, item T) T) []T
DifferenceBy it accepts iteratee which is invoked for each element of slice and values to generate the criterion by which they're compared. like lodash.js differenceBy: https://lodash.com/docs/4.17.15#differenceBy. Play: https://golang.ir/play/p/DiivgwM5OnC
Example ¶
slice1 := []int{1, 2, 3, 4, 5} //after add one: 2 3 4 5 6 slice2 := []int{3, 4, 5} //after add one: 4 5 6 addOne := func(i int, v int) int { return v + 1 } result := DifferenceBy(slice1, slice2, addOne) fmt.Println(result)
Output: [1 2]
func DifferenceWith ¶
DifferenceWith accepts comparator which is invoked to compare elements of slice to values. The order and references of result values are determined by the first slice. The comparator is invoked with two arguments: (arrVal, othVal). Play: https://golang.ir/play/p/v2U2deugKuV
Example ¶
slice1 := []int{1, 2, 3, 4, 5} slice2 := []int{4, 5, 6, 7, 8} isDouble := func(v1, v2 int) bool { return v2 == 2*v1 } result := DifferenceWith(slice1, slice2, isDouble) fmt.Println(result)
Output: [1 5]
func Drop ¶
Drop creates a slice with `n` elements dropped from the beginning when n > 0, or `n` elements dropped from the ending when n < 0. Play: https://golang.ir/play/p/pJ-d6MUWcvK
Example ¶
result1 := Drop([]string{"a", "b", "c"}, 0) result2 := Drop([]string{"a", "b", "c"}, 1) result3 := Drop([]string{"a", "b", "c"}, -1) result4 := Drop([]string{"a", "b", "c"}, 4) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) fmt.Println(result4)
Output: [a b c] [b c] [a b] []
func Equal ¶
func Equal[T comparable](slice1, slice2 []T) bool
Equal checks if two slices are equal: the same length and all elements' order and value are equal. Play: https://golang.ir/play/p/WcRQJ37ifPa
Example ¶
slice1 := []int{1, 2, 3} slice2 := []int{1, 2, 3} slice3 := []int{1, 3, 2} result1 := Equal(slice1, slice2) result2 := Equal(slice1, slice3) fmt.Println(result1) fmt.Println(result2)
Output: true false
func EqualWith ¶
EqualWith checks if two slices are equal with comparator func. Play: https://golang.ir/play/p/b9iygtgsHI1
Example ¶
slice1 := []int{1, 2, 3} slice2 := []int{2, 4, 6} isDouble := func(a, b int) bool { return b == a*2 } result := EqualWith(slice1, slice2, isDouble) fmt.Println(result)
Output: true
func Every ¶
Every return true if all of the values in the slice pass the predicate function. Play: https://golang.ir/play/p/R8U6Sl-j8cD
Example ¶
nums := []int{1, 2, 3, 5} isEven := func(i, num int) bool { return num%2 == 0 } result := Every(nums, isEven) fmt.Println(result)
Output: false
func Filter ¶
Filter iterates over elements of slice, returning an slice of all elements pass the predicate function. Play: https://golang.ir/play/p/SdPna-7qK4T
Example ¶
nums := []int{1, 2, 3, 4, 5} isEven := func(i, num int) bool { return num%2 == 0 } result := Filter(nums, isEven) fmt.Println(result)
Output: [2 4]
func Find ¶
Find iterates over elements of slice, returning the first one that passes a truth test on predicate function. If return T is nil then no items matched the predicate func. Play: https://golang.ir/play/p/CBKeBoHVLgq
Example ¶
nums := []int{1, 2, 3, 4, 5} isEven := func(i, num int) bool { return num%2 == 0 } result, ok := Find(nums, isEven) fmt.Println(*result) fmt.Println(ok)
Output: 2 true
func FindLast ¶
FindLast iterates over elements of slice from end to begin, return the first one that passes a truth test on predicate function. If return T is nil then no items matched the predicate func. Play: https://golang.ir/play/p/FFDPV_j7URd
Example ¶
nums := []int{1, 2, 3, 4, 5} isEven := func(i, num int) bool { return num%2 == 0 } result, ok := FindLast(nums, isEven) fmt.Println(*result) fmt.Println(ok)
Output: 4 true
func Flatten ¶
Flatten flattens slice with one level. Play: https://golang.ir/play/p/hYa3cBEevtm
Example ¶
arrs := [][][]string{{{"a", "b"}}, {{"c", "d"}}} result := Flatten(arrs) fmt.Println(result)
Output: [[a b] [c d]]
func FlattenDeep ¶
FlattenDeep flattens slice recursive. Play: https://golang.ir/play/p/yjYNHPyCFaF
Example ¶
arrs := [][][]string{{{"a", "b"}}, {{"c", "d"}}} result := FlattenDeep(arrs) fmt.Println(result)
Output: [a b c d]
func ForEach ¶
ForEach iterates over elements of slice and invokes function for each element. Play: https://golang.ir/play/p/DrPaa4YsHRF
Example ¶
nums := []int{1, 2, 3} var result []int addOne := func(_ int, v int) { result = append(result, v+1) } ForEach(nums, addOne) fmt.Println(result)
Output: [2 3 4]
func GroupBy ¶
GroupBy iterate over elements of the slice, each element will be group by criteria, returns two slices. Play: https://golang.ir/play/p/QVkPxzPR0iA
Example ¶
nums := []int{1, 2, 3, 4, 5} isEven := func(i, num int) bool { return num%2 == 0 } even, odd := GroupBy(nums, isEven) fmt.Println(even) fmt.Println(odd)
Output: [2 4] [1 3 5]
func GroupWith ¶
func GroupWith[T any, U comparable](slice []T, iteratee func(item T) U) map[U][]T
GroupWith return a map composed of keys generated from the resultults of running each element of slice thru iteratee. Play: https://golang.ir/play/p/ApCvMNTLO8a
Example ¶
nums := []float64{6.1, 4.2, 6.3} floor := func(num float64) float64 { return math.Floor(num) } result := GroupWith(nums, floor) //map[float64][]float64 fmt.Println(result)
Output: map[4:[4.2] 6:[6.1 6.3]]
func IndexOf ¶
func IndexOf[T comparable](arr []T, val T) int
IndexOf returns the index at which the first occurrence of an item is found in a slice or return -1 if the item cannot be found. Play: https://golang.ir/play/p/MRN1f0FpABb
Example ¶
strs := []string{"a", "a", "b", "c"} result1 := IndexOf(strs, "a") result2 := IndexOf(strs, "d") fmt.Println(result1) fmt.Println(result2)
Output: 0 -1
func InsertAt ¶
InsertAt insert the value or other slice into slice at index. Play: https://golang.ir/play/p/hMLNxPEGJVE
Example ¶
result1 := InsertAt([]string{"a", "b", "c"}, 0, "1") result2 := InsertAt([]string{"a", "b", "c"}, 1, "1") result3 := InsertAt([]string{"a", "b", "c"}, 2, "1") result4 := InsertAt([]string{"a", "b", "c"}, 3, "1") result5 := InsertAt([]string{"a", "b", "c"}, 0, []string{"1", "2", "3"}) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) fmt.Println(result4) fmt.Println(result5)
Output: [1 a b c] [a 1 b c] [a b 1 c] [a b c 1] [1 2 3 a b c]
func IntSlice ¶
IntSlice convert param to slice of int. This function is deprecated, use generics feature of go1.18+ for replacement. Play: https://golang.ir/play/p/UQDj-on9TGN
Example ¶
nums := []interface{}{1, 2, 3} result := IntSlice(nums) //[]int{1, 2, 3} fmt.Println(result)
Output: [1 2 3]
func InterfaceSlice ¶
InterfaceSlice convert param to slice of interface. This function is deprecated, use generics feature of go1.18+ for replacement. Play: https://golang.ir/play/p/FdQXF0Vvqs-
Example ¶
strs := []string{"a", "b", "c"} result := InterfaceSlice(strs) //[]interface{}{"a", "b", "c"} fmt.Println(result)
Output: [a b c]
func Intersection ¶
func Intersection[T comparable](slices ...[]T) []T
Intersection creates a slice of unique elements that included by all slices. Play: https://golang.ir/play/p/anJXfB5wq_t
Example ¶
nums1 := []int{1, 2, 3} nums2 := []int{2, 3, 4} result := Intersection(nums1, nums2) fmt.Println(result)
Output: [2 3]
func KeyBy ¶
func KeyBy[T any, U comparable](slice []T, iteratee func(item T) U) map[U]T
KeyBy converts a slice to a map based on a callback function. Play: https://golang.ir/play/p/uXod2LWD1Kg
Example ¶
result := KeyBy([]string{"a", "ab", "abc"}, func(str string) int { return len(str) }) fmt.Println(result)
Output: map[1:a 2:ab 3:abc]
func LastIndexOf ¶
func LastIndexOf[T comparable](slice []T, item T) int
LastIndexOf returns the index at which the last occurrence of the item is found in a slice or return -1 if the then cannot be found. Play: https://golang.ir/play/p/DokM4cf1IKH
Example ¶
strs := []string{"a", "a", "b", "c"} result1 := LastIndexOf(strs, "a") result2 := LastIndexOf(strs, "d") fmt.Println(result1) fmt.Println(result2)
Output: 1 -1
func Map ¶
Map creates an slice of values by running each element of slice thru iteratee function. Play: https://golang.ir/play/p/biaTefqPquw
Example ¶
nums := []int{1, 2, 3} addOne := func(_ int, v int) int { return v + 1 } result := Map(nums, addOne) fmt.Println(result)
Output: [2 3 4]
func Merge ¶
func Merge[T any](slices ...[]T) []T
Merge all given slices into one slice. Play: https://golang.ir/play/p/lbjFp784r9N
Example ¶
nums1 := []int{1, 2, 3} nums2 := []int{3, 4} result := Merge(nums1, nums2) fmt.Println(result)
Output: [1 2 3 3 4]
func None ¶
None return true if all the values in the slice mismatch the criteria. Play: https://golang.ir/play/p/KimdalUlC-T
Example ¶
nums := []int{1, 3, 5} isEven := func(i, num int) bool { return num%2 == 0 } result := None(nums, isEven) fmt.Println(result)
Output: true
func Reduce ¶
Reduce creates an slice of values by running each element of slice thru iteratee function. Play: https://golang.ir/play/p/_RfXJJWIsIm
Example ¶
nums := []int{1, 2, 3} sum := func(_ int, v1, v2 int) int { return v1 + v2 } result := Reduce(nums, sum, 0) fmt.Println(result)
Output: 6
func Repeat ¶
Repeat creates a slice with length n whose elements are param `item`. Play: https://golang.ir/play/p/1CbOmtgILUU
Example ¶
result := Repeat("a", 3) fmt.Println(result)
Output: [a a a]
func Replace ¶
func Replace[T comparable](slice []T, old T, new T, n int) []T
Replace returns a copy of the slice with the first n non-overlapping instances of old replaced by new. Play: https://golang.ir/play/p/P5mZp7IhOFo
Example ¶
strs := []string{"a", "b", "c", "a"} result1 := Replace(strs, "a", "x", 0) result2 := Replace(strs, "a", "x", 1) result3 := Replace(strs, "a", "x", 2) result4 := Replace(strs, "a", "x", 3) result5 := Replace(strs, "a", "x", -1) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) fmt.Println(result4) fmt.Println(result5)
Output: [a b c a] [x b c a] [x b c x] [x b c x] [x b c x]
func ReplaceAll ¶
func ReplaceAll[T comparable](slice []T, old T, new T) []T
ReplaceAll returns a copy of the slice with all non-overlapping instances of old replaced by new. Play: https://golang.ir/play/p/CzqXMsuYUrx
Example ¶
result := ReplaceAll([]string{"a", "b", "c", "a"}, "a", "x") fmt.Println(result)
Output: [x b c x]
func Reverse ¶
func Reverse[T any](slice []T)
Reverse return slice of element order is reversed to the given slice. Play: https://golang.ir/play/p/8uI8f1lwNrQ
Example ¶
strs := []string{"a", "b", "c", "d"} Reverse(strs) fmt.Println(strs)
Output: [d c b a]
func Shuffle ¶
func Shuffle[T any](slice []T) []T
Shuffle the slice. Play: https://golang.ir/play/p/YHvhnWGU3Ge
func Some ¶
Some return true if any of the values in the list pass the predicate function. Play: https://golang.ir/play/p/4pO9Xf9NDGS
Example ¶
nums := []int{1, 2, 3, 5} isEven := func(i, num int) bool { return num%2 == 0 } result := Some(nums, isEven) fmt.Println(result)
Output: true
func Sort ¶
func Sort[T constraints.Ordered](slice []T, sortOrder ...string)
Sort sorts a slice of any ordered type(number or string), use quick sort algrithm. default sort order is ascending (asc), if want descending order, set param `sortOrder` to `desc`. Play: https://golang.ir/play/p/V9AVjzf_4Fk
Example ¶
nums := []int{1, 4, 3, 2, 5} Sort(nums) fmt.Println(nums)
Output: [1 2 3 4 5]
func SortBy ¶
SortBy sorts the slice in ascending order as determined by the less function. This sort is not guaranteed to be stable. Play: https://golang.ir/play/p/DAhLQSZEumm
Example ¶
type User struct { Name string Age uint } users := []User{ {Name: "a", Age: 21}, {Name: "b", Age: 15}, {Name: "c", Age: 100}} SortBy(users, func(a, b User) bool { return a.Age < b.Age }) fmt.Println(users)
Output: [{b 15} {a 21} {c 100}]
func SortByField ¶
SortByField return sorted slice by field slice element should be struct, field type should be int, uint, string, or bool default sortType is ascending (asc), if descending order, set sortType to desc This function is deprecated, use Sort and SortBy for replacement. Play: https://golang.ir/play/p/fU1prOBP9p1
Example ¶
type User struct { Name string Age uint } users := []User{ {Name: "a", Age: 21}, {Name: "b", Age: 15}, {Name: "c", Age: 100}} err := SortByField(users, "Age", "desc") if err != nil { return } fmt.Println(users)
Output: [{c 100} {a 21} {b 15}]
func StringSlice ¶
StringSlice convert param to slice of string. This function is deprecated, use generics feature of go1.18+ for replacement. Play: https://golang.ir/play/p/W0TZDWCPFcI
Example ¶
strs := []interface{}{"a", "b", "c"} result := StringSlice(strs) //[]string{"a", "b", "c"} fmt.Println(result)
Output: [a b c]
func SymmetricDifference ¶
func SymmetricDifference[T comparable](slices ...[]T) []T
SymmetricDifference oppoiste operation of intersection function. Play: https://golang.ir/play/p/h42nJX5xMln
Example ¶
nums1 := []int{1, 2, 3} nums2 := []int{1, 2, 4} result := SymmetricDifference(nums1, nums2) fmt.Println(result)
Output: [3 4]
func ToSlice ¶
func ToSlice[T any](items ...T) []T
ToSlice returns a slices of a variable parameter transformation. Play: https://golang.ir/play/p/YzbzVq5kscN
Example ¶
result := ToSlice("a", "b", "c") fmt.Println(result)
Output: [a b c]
func ToSlicePointer ¶
func ToSlicePointer[T any](items ...T) []*T
ToSlicePointer returns a pointer to the slices of a variable parameter transformation. Play: https://golang.ir/play/p/gx4tr6_VXSF
Example ¶
str1 := "a" str2 := "b" result := ToSlicePointer(str1, str2) expect := []*string{&str1, &str2} isEqual := reflect.DeepEqual(result, expect) fmt.Println(isEqual)
Output: true
func Union ¶
func Union[T comparable](slices ...[]T) []T
Union creates a slice of unique elements, in order, from all given slices. Play: https://golang.ir/play/p/hfXV1iRIZOf
Example ¶
nums1 := []int{1, 3, 4, 6} nums2 := []int{1, 2, 5, 6} result := Union(nums1, nums2) fmt.Println(result)
Output: [1 3 4 6 2 5]
func UnionBy ¶
func UnionBy[T any, V comparable](predicate func(item T) V, slices ...[]T) []T
UnionBy is like Union, what's more it accepts iteratee which is invoked for each element of each slice. Play: https://golang.ir/play/p/HGKHfxKQsFi
Example ¶
nums := []int{1, 2, 3, 4} divideTwo := func(n int) int { return n / 2 } result := UnionBy(divideTwo, nums) fmt.Println(result)
Output: [1 2 4]
func Unique ¶
func Unique[T comparable](slice []T) []T
Unique remove duplicate elements in slice. Play: https://golang.ir/play/p/AXw0R3ZTE6a
Example ¶
result := Unique([]string{"a", "a", "b"}) fmt.Println(result)
Output: [a b]
func UniqueBy ¶
func UniqueBy[T comparable](slice []T, iteratee func(item T) T) []T
UniqueBy call iteratee func with every item of slice, then remove duplicated. Play: https://golang.ir/play/p/UR323iZLDpv
Example ¶
nums := []int{1, 2, 3, 4, 5, 6} result := UniqueBy(nums, func(val int) int { return val % 3 }) fmt.Println(result)
Output: [1 2 0]
func UpdateAt ¶
UpdateAt update the slice element at index. Play: https://golang.ir/play/p/f3mh2KloWVm
Example ¶
result1 := UpdateAt([]string{"a", "b", "c"}, -1, "1") result2 := UpdateAt([]string{"a", "b", "c"}, 0, "1") result3 := UpdateAt([]string{"a", "b", "c"}, 1, "1") result4 := UpdateAt([]string{"a", "b", "c"}, 2, "1") result5 := UpdateAt([]string{"a", "b", "c"}, 3, "1") fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) fmt.Println(result4) fmt.Println(result5)
Output: [a b c] [1 b c] [a 1 c] [a b 1] [a b c]
func Without ¶
func Without[T comparable](slice []T, items ...T) []T
Without creates a slice excluding all given items. Play: https://golang.ir/play/p/bwhEXEypThg
Example ¶
result := Without([]int{1, 2, 3, 4}, 1, 2) fmt.Println(result)
Output: [3 4]
Types ¶
This section is empty.