21 KiB
Slice
Package slice implements some functions to manipulate slice.
Source:
https://github.com/duke-git/lancet/blob/v1/slice/slice.go
Usage:
import (
"github.com/duke-git/lancet/slice"
)
Index
- AppendIfAbsent
- Contain
- ContainSubSlice
- Chunk
- Compact
- Concat
- Count
- Difference
- DifferenceBy
- DeleteByIndex
- Drop
- Equal
- EqualWith
- Every
- Filter
- Find
- FindLast
- FlattenDeep
- ForEach
- GroupBy
- IntSlice
- InterfaceSlice
- Intersection
- InsertByIndex
- IndexOf
- LastIndexOf
- Map
- ReverseSlice
- Reduce
- Shuffle
- SortByField
- Some
- StringSlice
- ToSlice
- ToSlicePointer
- Unique
- UniqueBy
- Union
- UpdateByIndex
- Without
Documentation
Note:
- param which type is interface{} in below functions should be slice.
AppendIfAbsent
If slice doesn't contain the value, append it to the slice.
Signature:
func AppendIfAbsent(slice interface{}, value interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
strs := []string{"a", "b"}
res1 := slice.AppendIfAbsent(strs, "a")
fmt.Println(res1) //[]string{"a", "b"}
res2 := slice.AppendIfAbsent(strs, "cannot")
fmt.Println(res2"}
}
Contain
Check if the value is in the slice or not. iterableType param can be string, map or slice.
Signature:
func Contain(iterableType interface{}, value interface{}) bool
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
res := slice.Contain([]string{"a", "b", "c"}, "a")
fmt.Println(res) //true
}
ContainSubSlice
Check if the slice contain subslice or not.
Signature:
func ContainSubSlice(slice interface{}, subslice interface{}) bool
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
res := slice.ContainSubSlice([]string{"a", "b", "c"}, []string{"a", "b"})
fmt.Println(res) //true
}
Chunk
Creates an slice of elements split into groups the length of `size`.
Signature:
func Chunk(slice []interface{}, size int) [][]interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
arr := []string{"a", "b", "c", "d", "e"}
res := slice.Chunk(InterfaceSlice(arr), 3)
fmt.Println(res) //[][]interface{}{{"a", "b", "c"}, {"d", "e"}}
}
Compact
Creates an slice with all falsey values removed. The values false, nil, 0, and "" are falsey.
Signature:
func Compact(slice interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
res := slice.Compact([]int{0, 1, 2, 3})
fmt.Println(res) //[]int{1, 2, 3}
}
Concat
Creates a new slice concatenating slice with any additional slices and/or values.
Signature:
func Concat(slice interface{}, values ...interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
res1 := slice.Concat([]int{1, 2, 3}, 4, 5)
fmt.Println(res1) //[]int{1, 2, 3, 4, 5}
res2 := slice.Concat([]int{1, 2, 3}, []int{4, 5})
fmt.Println(res2) //[]int{1, 2, 3, 4, 5}
}
Count
Count iterates over elements of slice, returns a count of all matched elements. The function signature should be func(index int, value interface{}) bool.
Signature:
func Count(slice, function interface{}) int
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
nums := []int{1, 2, 3, 4, 5, 6}
evenFunc := func(i, num int) bool {
return (num % 2) == 0
}
res := slice.Count(nums, evenFunc)
fmt.Println(res) //3
}
Difference
Creates an slice of whose element not included in the other given slice.
Signature:
func Difference(slice1, slice2 interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
s1 := []int{1, 2, 3, 4, 5}
s2 := []int{4, 5, 6}
res := slice.Difference(s1, s2)
fmt.Println(res) //[]int{1, 2, 3}
}
DifferenceBy
DifferenceBy accepts iteratee func which is invoked for each element of slice and values to generate the criterion by which they're compared.
Signature:
func DifferenceBy(slice interface{}, comparedSlice interface{}, iterateeFn interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
s1 := []int{1, 2, 3, 4, 5}
s2 := []int{4, 5, 6}
addOne := func(i int, v int) int {
return v + 1
}
res := slice.DifferenceBy(s1, s2, addOne)
fmt.Println(res) //[]int{1, 2}
}
DeleteByIndex
Delete the element of slice from start index to end index - 1.
Signature:
func DeleteByIndex(slice interface{}, start int, end ...int) (interface{}, error)
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
res1 := slice.DeleteByIndex([]string{"a", "b", "c", "d", "e"}, 3)
fmt.Println(res1) //[]string{"a", "b", "c", "e"}
res2 := slice.DeleteByIndex([]string{"a", "b", "c", "d", "e"}, 0, 2)
fmt.Println(res2) //[]string{"c", "d", "e"}
}
Drop
Creates a slice with `n` elements dropped from the beginning when n > 0, or `n` elements dropped from the ending when n < 0.
Signature:
func Drop(slice interface{}, n int) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
res1 := slice.Drop([]int{}, 0)
fmt.Println(res1) //[]int{}
res2 := slice.Drop([]int{1, 2, 3, 4, 5}, 1)
fmt.Println(res2) //[]int{2, 3, 4, 5}
res3 := slice.Drop([]int{1, 2, 3, 4, 5}, -1)
fmt.Println(res3) //[]int{1, 2, 3, 4}
}
Equal
Check if two slices are equal: the same length and all elements' order and value are equal.
Signature:
func Equal(slice1, slice2 interface{}) bool
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
slice1 := []int{1, 2, 3}
slice2 := []int{1, 2, 3}
slice3 := []int{3, 2, 1}
res1 := slice.Equal(slice1, slice2)
res2 := slice.Equal(slice1, slice3)
fmt.Println(res1) //true
fmt.Println(res2) //false
}
EqualWith
Check if two slices are equal with comparator funcation.comparator signature: func(a interface{}, b interface{}) bool
Signature:
func EqualWith(slice1, slice2 interface{}, comparator interface{}) bool
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
slice1 := []int{1, 2, 3}
slice2 := []int{2, 4, 6}
isDouble := func(a, b int) bool {
return b == a*2
}
res := slice.EqualWith(slice1, slice2, isDouble)
fmt.Println(res) //true
}
Every
Return true if all of the values in the slice pass the predicate function. The function signature should be func(index int, value interface{}) bool.
Signature:
func Every(slice, function interface{}) bool
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
nums := []int{1, 2, 3, 5}
isEven := func(i, num int) bool {
return num%2 == 0
}
res := slice.Every(nums, isEven)
fmt.Println(res) //false
}
Filter
Return all elements which match the function. Function signature should be func(index int, value interface{}) bool.
Signature:
func Filter(slice, function interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
nums := []int{1, 2, 3, 5}
isEven := func(i, num int) bool {
return num%2 == 0
}
res := slice.Filter(nums, isEven)
fmt.Println(res) //[]int{2, 4}
}
Find
Iterates over elements of slice, returning the first one that passes a truth test on function.function signature should be func(index int, value interface{}) bool.
Signature:
func Find(slice, function interface{}) (interface{}, bool)
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
nums := []int{1, 2, 3, 5}
isEven := func(i, num int) bool {
return num%2 == 0
}
res, ok := slice.Find(nums, even)
fmt.Println(res) //2
fmt.Println(ok) //true
}
FindLast
iterates over elements of slice from end to begin, returning the last one that passes a truth test on function. The function signature should be func(index int, value interface{}) bool.
Signature:
func FindLast(slice, function interface{}) (interface{}, bool)
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
nums := []int{1, 2, 3, 5}
isEven := func(i, num int) bool {
return num%2 == 0
}
res, ok := slice.FindLast(nums, even)
fmt.Println(res) //4
fmt.Println(ok) //true
}
FlattenDeep
flattens slice recursive.
Signature:
func FlattenDeep(slice interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
arr := [][][]string{{{"a", "b"}}, {{"c", "d"}}}
res := slice.FlattenDeep(arr)
fmt.Println(res) //[]string{"a", "b", "c", "d"}
}
ForEach
Iterates over elements of slice and invokes function for each element, function signature should be func(index int, value interface{}).
Signature:
func ForEach(slice, function interface{})
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
numbers := []int{1, 2, 3, 4, 5}
var numbersAddTwo []int
slice.ForEach(numbers, func(index int, value int) {
numbersAddTwo = append(numbersAddTwo, value+2)
})
fmt.Println(numbersAddTwo) //[]int{3, 4, 5, 6, 7}
}
GroupBy
Iterates over elements of the slice, each element will be group by criteria, returns two slices. The function signature should be func(index int, value interface{}) bool.
Signature:
func GroupBy(slice, function interface{}) (interface{}, interface{})
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
nums := []int{1, 2, 3, 4, 5, 6}
evenFunc := func(i, num int) bool {
return (num % 2) == 0
}
even, odd := slice.GroupBy(nums, evenFunc)
fmt.Println(even) //[]int{2, 4, 6}
fmt.Println(odd) //]int{1, 3, 5}
}
IntSlice
Convert interface slice to int slice.
Signature:
func IntSlice(slice interface{}) []int
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
var nums = []interface{}{1, 2, 3}
res := slice.IntSlice(nums)
fmt.Println(res) //[]int{1, 2, 3}
}
InterfaceSlice
Convert value to interface slice.
Signature:
func InterfaceSlice(slice interface{}) []interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
var nums = []int{}{1, 2, 3}
res := slice.InterfaceSlice(nums)
fmt.Println(res) //[]interface{}{1, 2, 3}
}
Intersection
Creates a slice of unique values that included by all slices.
Signature:
func Intersection(slices ...interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
s1 := []int{1, 2, 2, 3}
s2 := []int{1, 2, 3, 4}
res := slice.Intersection(s1, s2),
fmt.Println(res) //[]int{1, 2, 3}
}
IndexOf
Returns the index at which the first occurrence of a value is found in a slice or return -1 if the value cannot be found.
Signature:
func IndexOf(slice, value interface{}) int
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
arr := []string{"a", "a", "b", "c"}
res1 := slice.IndexOf(arr, "a")
fmt.Println(res1) //0
res2 := slice.IndexOf(arr, "d")
fmt.Println(res2) //-1
}
LastIndexOf
Returns the index at which the last occurrence of a value is found in a slice or return -1 if the value cannot be found.
Signature:
func LastIndexOf(slice, value interface{}) int
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
arr := []string{"a", "a", "b", "c"}
res1 := slice.LastIndexOf(arr, "a")
fmt.Println(res1) //1
res2 := slice.LastIndexOf(arr, "d")
fmt.Println(res2) //-1
}
InsertByIndex
insert the element into slice at index.
Signature:
func InsertByIndex(slice interface{}, index int, value interface{}) (interface{}, error)
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
s := []string{"a", "b", "c"}
res1, _ := slice.InsertByIndex(s, 0, "1")
fmt.Println(res1) //[]string{"1", "a", "b", "c"}
res2, _ := slice.InsertByIndex(s, 3, []string{"1", "2", "3"})
fmt.Println(res2) //[]string{"a", "b", "c", "1", "2", "3"}
}
Map
Creates an slice of values by running each element in slice thru function, function signature should be func(index int, value interface{}) interface{}.
Signature:
func Map(slice, function interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
nums := []int{1, 2, 3, 4}
multiplyTwo := func(i, num int) int {
return num * 2
}
res := slice.Map(nums, multiplyTwo)
fmt.Println(res) //[]int{2, 4, 6, 8}
}
ReverseSlice
Reverse the elements order in slice.
Signature:
func ReverseSlice(slice interface{})
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
nums := []int{1, 2, 3, 4}
slice.ReverseSlice(nums)
fmt.Println(res) //[]int{4, 3, 2, 1}
}
Reduce
Reduce slice, function signature should be func(index int, value1, value2 interface{}) interface{}.
Signature:
func Reduce(slice, function, zero interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
nums := []int{1, 2, 3, 4}
reduceFunc := func(i, v1, v2 int) int {
return v1 + v2
}
res := slice.Reduce(nums, reduceFunc, 0)
fmt.Println(res) //10
}
Shuffle
Creates an slice of shuffled values.
Signature:
func Shuffle(slice interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
nums := []int{1, 2, 3, 4, 5}
res := slice.Shuffle(nums)
fmt.Println(res) //3,1,5,4,2
}
SortByField
Sort struct slice by field. Slice element should be struct, field type should be int, uint, string, or bool. Default sort type is ascending (asc), if descending order, set sortType to desc
Signature:
func SortByField(slice interface{}, field string, sortType ...string) error
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
type student struct {
name string
age int
}
students := []student{
{"a", 10},
{"b", 15},
{"c", 5},
{"d", 6},
}
err := slice.SortByField(students, "age", "desc")
if err != nil {
fmt.Println(err)
}
fmt.Println(students)
// []students{
// {"b", 15},
// {"a", 10},
// {"d", 6},
// {"c", 5},
// }
}
Some
Return true if any of the values in the list pass the predicate function, function signature should be func(index int, value interface{}) bool.
Signature:
func Some(slice, function interface{}) bool
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
nums := []int{1, 2, 3, 5}
isEven := func(i, num int) bool {
return num%2 == 0
}
res := slice.Some(nums, isEven)
fmt.Println(res) //true
}
StringSlice
Convert interface slice to string slice.
Signature:
func StringSlice(slice interface{}) []string
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
var s = []interface{}{"a", "b", "c"}
res := slice.StringSlice(s)
fmt.Println(res) //[]string{"a", "b", "c"}
}
ToSlice
Returns a slices of a variable parameter transformation
Signature:
func ToSlice(value ...interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
res := slice.ToSlice("a", "b")
fmt.Println(res) //{"a", "b"}
}
ToSlicePointer
Returns a pointer to the slices of a variable parameter transformation
Signature:
func ToSlicePointer(value ...interface{}) []*interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
str1 := "a"
str2 := "b"
res := slice.ToSlicePointer(str1, str2)
fmt.Println(res) // res -> []*string{&str1, &str2}
}
Unique
Remove duplicate elements in slice.
Signature:
func Unique(slice interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
res := slice.Unique([]int{1, 2, 2, 3})
fmt.Println(res) //[]int{1, 2, 3}
}
UniqueBy
Call iteratee func with every item of slice, then remove duplicated.
Signature:
func UniqueBy(slice, iteratee interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
res := slice.UniqueBy([]int{1, 2, 3, 4, 5, 6}, func(val int) int {
return val % 4
})
fmt.Println(res) //[]int{1, 2, 3, 0}
}
Union
Creates a slice of unique values, in order, from all given slices. using == for equality comparisons.
Signature:
func Union(slices ...interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
s1 := []int{1, 3, 4, 6}
s2 := []int{1, 2, 5, 6}
res := slice.Union(s1, s2)
fmt.Println(res) //[]int{1, 3, 4, 6, 2, 5}
}
UpdateByIndex
Update the slice element at index. if param index < 0 or index >= len(slice), will return error.
Signature:
func UpdateByIndex(slice interface{}, index int, value interface{}) (interface{}, error)
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
s := []string{"a", "b", "c"}
res1, _ := slice.UpdateByIndex(s, 0, "1")
fmt.Println(res1) //[]string{"1", "b", "c"}
}
Without
Creates a slice excluding all given values.
Signature:
func Without(slice interface{}, values ...interface{}) interface{}
Example:
import (
"fmt"
"github.com/duke-git/lancet/slice"
)
func main() {
res := slice.Without([]int{1, 2, 3, 4, 5}, 1, 2)
fmt.Println(res) //[]int{3, 4, 5}
}