git/lancet

Fork 0

mirror of https://github.com/duke-git/lancet.git synced 2026-02-04 21:02:27 +08:00

Files

dudaodong f976941e36 doc: normalize document

2023-01-14 12:32:27 +08:00

31 KiB

Raw Blame History

Slice

Package slice implements some functions to manipulate slice.

Source:

https://github.com/duke-git/lancet/blob/main/slice/slice.go

Usage:

import (
    "github.com/duke-git/lancet/v2/slice"
)

Index

AppendIfAbsent
Contain
ContainSubSlice
Chunk
Compact
Concat
Count
CountBy
Difference
DifferenceBy
DifferenceWith
DeleteAt
Drop
Equal
EqualWith
Every
Filter
Find
FindLast
Flatten
FlattenDeep
ForEach
GroupBy
GroupWith
IntSlice^deprecated
InterfaceSlice^deprecated
Intersection
InsertAt
IndexOf
LastIndexOf
Map
Merge
Reverse
Reduce
Replace
ReplaceAll
Repeat
Shuffle
Sort
SortBy
SortByField^deprecated
Some
StringSlice^deprecated
SymmetricDifference
ToSlice
ToSlicePointer
Unique
UniqueBy
Union
UnionBy
UpdateAt
Without
KeyBy

Documentation

AppendIfAbsent

If slice doesn't contain the item, append it to the slice.

Signature:

func AppendIfAbsent[T comparable](slice []T, item T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result1 := slice.AppendIfAbsent([]string{"a", "b"}, "b")
    result2 := slice.AppendIfAbsent([]string{"a", "b"}, "c")

    fmt.Println(result1)
    fmt.Println(result2)

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

Contain

Check if the target value is in the slice or not.

Signature:

func Contain[T comparable](slice []T, target T) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result1 := slice.Contain([]string{"a", "b", "c"}, "a")
    result2 := slice.Contain([]int{1, 2, 3}, 4)

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // true
    // false
}

ContainSubSlice

Check if the slice contain subslice or not.

Signature:

func ContainSubSlice[T comparable](slice, subSlice []T) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result1 := slice.ContainSubSlice([]string{"a", "b", "c"}, []string{"a", "b"})
    result2 := slice.ContainSubSlice([]string{"a", "b", "c"}, []string{"a", "d"})

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // true
    // false
}

Chunk

Creates an slice of elements split into groups the length of `size`.

Signature:

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

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    arr := []string{"a", "b", "c", "d", "e"}

    result1 := slice.Chunk(arr, 1)
    result2 := slice.Chunk(arr, 2)
    result3 := slice.Chunk(arr, 3)
    result4 := slice.Chunk(arr, 4)
    result5 := slice.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]]
}

Compact

Creates an slice with all falsey values removed. The values false, nil, 0, and "" are falsey.

Signature:

func Compact[T comparable](slice []T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result1 := slice.Compact([]int{0})
    result2 := slice.Compact([]int{0, 1, 2, 3})
    result3 := slice.Compact([]string{"", "a", "b", "0"})
    result4 := slice.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]
}

Concat

Creates a new slice concatenating slice with any additional slices.

Signature:

func Concat[T any](slice []T, slices ...[]T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result1 := slice.Concat([]int{1, 2}, []int{3, 4})
    result2 := slice.Concat([]string{"a", "b"}, []string{"c"}, []string{"d"})

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // [1 2 3 4]
    // [a b c d]
}

Count

Returns the number of occurrences of the given item in the slice.

Signature:

func Count[T comparable](slice []T, item T) int

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []int{1, 2, 3, 3, 4}

    result1 := slice.Count(nums, 1)
    result2 := slice.Count(nums, 3)

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // 1
    // 2
}

CountBy

Iterates over elements of slice with predicate function, returns the number of all matched elements.

Signature:

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

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []int{1, 2, 3, 4, 5}

    isEven := func(i, num int) bool {
        return num%2 == 0
    }

    result := slice.CountBy(nums, isEven)

    fmt.Println(result)

    // Output:
    // 2
}

Difference

Creates an slice of whose element not included in the other given slice.

Signature:

func Difference[T comparable](slice, comparedSlice []T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    s1 := []int{1, 2, 3, 4, 5}
    s2 := []int{4, 5, 6}

    result := slice.Difference(s1, s2)

    fmt.Println(result)

    // Output:
    // [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[T comparable](slice []T, comparedSlice []T, iteratee func(index int, item T) T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    s1 := []int{1, 2, 3, 4, 5}
    s2 := []int{3, 4, 5}

    addOne := func(i int, v int) int {
        return v + 1
    }

    result := slice.DifferenceBy(s1, s2, addOne)

    fmt.Println(result)

    // Output:
    // [1 2]
}

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.

Signature:

func DifferenceWith[T any](slice []T, comparedSlice []T, comparator func(value, otherValue T) bool) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    s1 := []int{1, 2, 3, 4, 5}
    s2 := []int{4, 5, 6, 7, 8}

    isDouble := func(v1, v2 int) bool {
        return v2 == 2*v1
    }

    result := slice.DifferenceWith(s1, s2, isDouble)

    fmt.Println(result)

    // Output:
    // [1 5]
}

DeleteAt

Delete the element of slice from start index to end index - 1.

Signature:

func DeleteAt[T any](slice []T, start int, end ...int)

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result1 := slice.DeleteAt([]string{"a", "b", "c"}, -1)
    result2 := slice.DeleteAt([]string{"a", "b", "c"}, 0)
    result3 := slice.DeleteAt([]string{"a", "b", "c"}, 0, 2)

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)

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

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[T any](slice []T, n int) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result1 := slice.Drop([]string{"a", "b", "c"}, 0)
    result2 := slice.Drop([]string{"a", "b", "c"}, 1)
    result3 := slice.Drop([]string{"a", "b", "c"}, -1)
    result4 := slice.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]
    // []
}

Equal

Check if two slices are equal: the same length and all elements' order and value are equal.

Signature:

func Equal[T comparable](slice1, slice2 []T) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    s1 := []int{1, 2, 3}
    s2 := []int{1, 2, 3}
    s3 := []int{1, 3, 2}

    result1 := slice.Equal(s1, s2)
    result2 := slice.Equal(s1, s3)

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // true
    // false
}

EqualWith

Check if two slices are equal with comparator func.

Signature:

func EqualWith[T, U any](slice1 []T, slice2 []U, comparator func(T, U) bool) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    s1 := []int{1, 2, 3}
    s2 := []int{2, 4, 6}

    isDouble := func(a, b int) bool {
        return b == a*2
    }

    result := slice.EqualWith(s1, s2, isDouble)

    fmt.Println(result)

    // Output:
    // true
}

Every

Return true if all of the values in the slice pass the predicate function.

Signature:

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

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []int{1, 2, 3, 5}

    isEven := func(i, num int) bool {
        return num%2 == 0
    }

    result := slice.Every(nums, isEven)

    fmt.Println(result)

    // Output:
    // false
}

Filter

Return all elements which match the function.

Signature:

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

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []int{1, 2, 3, 4, 5}

    isEven := func(i, num int) bool {
        return num%2 == 0
    }

    result := slice.Filter(nums, isEven)

    fmt.Println(result)

    // Output:
    // [2 4]
}

Find

Iterates over elements of slice, returning the first one that passes a truth test on function.

Signature:

func Find[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []int{1, 2, 3, 4, 5}

    isEven := func(i, num int) bool {
        return num%2 == 0
    }

    result, ok := slice.Find(nums, isEven)

    fmt.Println(*result)
    fmt.Println(ok)

    // Output:
    // 2
    // true
}

FindLast

iterates over elements of slice from end to begin, returning the last one that passes a truth test on function.

Signature:

func FindLast[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []int{1, 2, 3, 4, 5}

    isEven := func(i, num int) bool {
        return num%2 == 0
    }

    result, ok := slice.FindLast(nums, isEven)

    fmt.Println(*result)
    fmt.Println(ok)

    // Output:
    // 4
    // true
}

Flatten

Flatten slice with one level.

Signature:

func Flatten(slice any) any

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    arrs := [][][]string{{{"a", "b"}}, {{"c", "d"}}}

    result := slice.Flatten(arrs)

    fmt.Println(result)

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

FlattenDeep

flattens slice recursive.

Signature:

func FlattenDeep(slice any) any

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    arrs := [][][]string{{{"a", "b"}}, {{"c", "d"}}}

    result := slice.FlattenDeep(arrs)

    fmt.Println(result)

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

ForEach

Iterates over elements of slice and invokes function for each element.

Signature:

func ForEach[T any](slice []T, iteratee func(index int, item T))

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []int{1, 2, 3}

    var result []int
    addOne := func(_ int, v int) {
        result = append(result, v+1)
    }

    slice.ForEach(nums, addOne)

    fmt.Println(result)

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

GroupBy

Iterates over elements of the slice, each element will be group by criteria, returns two slices.

Signature:

func GroupBy[T any](slice []T, groupFn func(index int, item T) bool) ([]T, []T)

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []int{1, 2, 3, 4, 5}

    isEven := func(i, num int) bool {
        return num%2 == 0
    }

    even, odd := slice.GroupBy(nums, isEven)

    fmt.Println(even)
    fmt.Println(odd)

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

GroupWith

Return a map composed of keys generated from the results of running each element of slice thru iteratee.

Signature:

func GroupWith[T any, U comparable](slice []T, iteratee func(T) U) map[U][]T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []float64{6.1, 4.2, 6.3}

    floor := func(num float64) float64 {
        return math.Floor(num)
    }

    result := slice.GroupWith(nums, floor) //map[float64][]float64

    fmt.Println(result)

    // Output:
    // map[4:[4.2] 6:[6.1 6.3]]
}

IntSlice (Deprecated: use generic feature of go1.18+ for replacement)

Convert interface slice to int slice.

Signature:

func IntSlice(slice any) []int

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []interface{}{1, 2, 3}

    result := slice.IntSlice(nums) //[]int{1, 2, 3}
    fmt.Println(result)

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

InterfaceSlice (Deprecated: use generic feature of go1.18+ for replacement)

Convert value to interface slice.

Signature:

func InterfaceSlice(slice any) []any

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    strs := []string{"a", "b", "c"}

    result := slice.InterfaceSlice(strs) //[]interface{}{"a", "b", "c"}
    fmt.Println(result)

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

Intersection

Creates a slice of unique values that included by all slices.

Signature:

func Intersection[T comparable](slices ...[]T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums1 := []int{1, 2, 3}
    nums2 := []int{2, 3, 4}

    result := slice.Intersection(nums1, nums2)

    fmt.Println(result)

    // Output:
    // [2 3]
}

InsertAt

insert the element into slice at index.

Signature:

func InsertAt[T any](slice []T, index int, value any) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result1 := slice.InsertAt([]string{"a", "b", "c"}, 0, "1")
    result2 := slice.InsertAt([]string{"a", "b", "c"}, 1, "1")
    result3 := slice.InsertAt([]string{"a", "b", "c"}, 2, "1")
    result4 := slice.InsertAt([]string{"a", "b", "c"}, 3, "1")
    result5 := slice.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]
}

IndexOf

Returns the index at which the first occurrence of a item is found in a slice or return -1 if the item cannot be found.

Signature:

func IndexOf[T comparable](slice []T, item T) int

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    strs := []string{"a", "a", "b", "c"}

    result1 := slice.IndexOf(strs, "a")
    result2 := slice.IndexOf(strs, "d")

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // 0
    // -1
}

LastIndexOf

Returns the index at which the last occurrence of a item is found in a slice or return -1 if the item cannot be found.

Signature:

func LastIndexOf[T comparable](slice []T, item T) int

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    strs := []string{"a", "a", "b", "c"}

    result1 := slice.LastIndexOf(strs, "a")
    result2 := slice.LastIndexOf(strs, "d")

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // 1
    // -1
}

Map

Creates an slice of values by running each element in slice thru function.

Signature:

func Map[T any, U any](slice []T, iteratee func(index int, item T) U) []U

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []int{1, 2, 3}

    addOne := func(_ int, v int) int {
        return v + 1
    }

    result := slice.Map(nums, addOne)

    fmt.Println(result)

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

Merge

Merge all given slices into one slice.

Signature:

func Merge[T any](slices ...[]T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums1 := []int{1, 2, 3}
    nums2 := []int{3, 4}

    result := slice.Merge(nums1, nums2)

    fmt.Println(result)

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

Reverse

Reverse the elements order in slice.

Signature:

func Reverse[T any](slice []T)

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    strs := []string{"a", "b", "c", "d"}

    slice.Reverse(strs)

    fmt.Println(strs)

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

Reduce

Reduce slice.

Signature:

func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initial T) T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []int{1, 2, 3}

    sum := func(_ int, v1, v2 int) int {
        return v1 + v2
    }

    result := slice.Reduce(nums, sum, 0)

    fmt.Println(result)

    // Output:
    // 6
}

Replace

Returns a copy of the slice with the first n non-overlapping instances of old replaced by new.

Signature:

func Replace[T comparable](slice []T, old T, new T, n int) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    strs := []string{"a", "b", "c", "a"}

    result1 := slice.Replace(strs, "a", "x", 0)
    result2 := slice.Replace(strs, "a", "x", 1)
    result3 := slice.Replace(strs, "a", "x", 2)
    result4 := slice.Replace(strs, "a", "x", 3)
    result5 := slice.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]
}

ReplaceAll

Returns a copy of the slice with the first n non-overlapping instances of old replaced by new.

Signature:

func ReplaceAll[T comparable](slice []T, old T, new T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result := slice.ReplaceAll([]string{"a", "b", "c", "a"}, "a", "x")

    fmt.Println(result)

    // Output:
    // [x b c x]
}

Repeat

Creates a slice with length n whose elements are passed param item.

Signature:

func Repeat[T any](item T, n int) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result := slice.Repeat("a", 3)

    fmt.Println(result)

    // Output:
    // [a a a]
}

Shuffle

Creates an slice of shuffled values.

Signature:

func Shuffle[T any](slice []T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []int{1, 2, 3, 4, 5}
    result := slice.Shuffle(nums)

    fmt.Println(res) 
    
    // Output:
    // [3 1 5 4 2] (random order)
}

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`. Ordered type: number(all ints uints floats) or string.

Signature:

func Sort[T constraints.Ordered](slice []T, sortOrder ...string)

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    numbers := []int{1, 4, 3, 2, 5}

    slice.Sort(numbers)
    fmt.Println(numbers) // [1 2 3 4 5]

    slice.Sort(numbers, "desc")
    fmt.Println(numbers) // [5 4 3 2 1]

    strings := []string{"a", "d", "c", "b", "e"}

    slice.Sort(strings)
    fmt.Println(strings) //[a b c d e}

    slice.Sort(strings, "desc")
    fmt.Println(strings) //[e d c b a]
}

SortBy

Sorts the slice in ascending order as determined by the less function. This sort is not guaranteed to be stable.

Signature:

func SortBy[T any](slice []T, less func(a, b T) bool)

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    numbers := []int{1, 4, 3, 2, 5}

    slice.SortBy(numbers, func(a, b int) bool {
        return a < b
    })
    fmt.Println(numbers) // [1 2 3 4 5]

    type User struct {
        Name string
        Age  uint
    }

    users := []User{
        {Name: "a", Age: 21},
        {Name: "b", Age: 15},
        {Name: "c", Age: 100}}

    slice.SortBy(users, func(a, b User) bool {
        return a.Age < b.Age
    })

    fmt.Printf("sort users by age: %v", users)

    // output
    // [{b 15} {a 21} {c 100}]
}

SortByField (Deprecated: use Sort and SortBy for replacement)

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 any, field string, sortType ...string) error

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    type User struct {
        Name string
        Age  uint
    }

    users := []User{
        {Name: "a", Age: 21},
        {Name: "b", Age: 15},
        {Name: "c", Age: 100}}

    err := slice.SortByField(users, "Age", "desc")
    if err != nil {
        return
    }

    fmt.Println(users)

    // Output:
    // [{c 100} {a 21} {b 15}]
}

Some

Return true if any of the values in the list pass the predicate function.

Signature:

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

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []int{1, 2, 3, 5}

    isEven := func(i, num int) bool {
        return num%2 == 0
    }

    result := slice.Some(nums, isEven)

    fmt.Println(result)

    // Output:
    // true
}

StringSlice (Deprecated: use generic feature of go1.18+ for replacement)

Convert interface slice to string slice.

Signature:

func StringSlice(slice any) []string

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    strs := []interface{}{"a", "b", "c"}

    result := slice.StringSlice(strs) //[]string{"a", "b", "c"}
    fmt.Println(result)

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

SymmetricDifference

Create a slice whose element is in given slices, but not in both slices.

Signature:

func SymmetricDifference[T comparable](slices ...[]T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums1 := []int{1, 2, 3}
    nums2 := []int{1, 2, 4}

    result := slice.SymmetricDifference(nums1, nums2)

    fmt.Println(result)

    // Output:
    // [3 4]
}

ToSlice

Creates a slice of give items.

Signature:

func ToSlice[T any](items ...T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result := slice.ToSlice("a", "b", "c")

    fmt.Println(result)

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

ToSlicePointer

Returns a pointer to the slices of a variable parameter transformation

Signature:

func ToSlicePointer[T any](items ...T) []*T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    str1 := "a"
    str2 := "b"

    result := slice.ToSlicePointer(str1, str2)

    expect := []*string{&str1, &str2}

    isEqual := reflect.DeepEqual(result, expect)

    fmt.Println(isEqual)

    // Output:
    // true
}

Unique

Remove duplicate elements in slice.

Signature:

func Unique[T comparable](slice []T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result := slice.Unique([]string{"a", "a", "b"})
    fmt.Println(result)

    // Output:
    // [a b]
}

UniqueBy

Call iteratee func with every item of slice, then remove duplicated.

Signature:

func UniqueBy[T comparable](slice []T, iteratee func(item T) T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/slice"
)

func main() {
    nums := []int{1, 2, 3, 4, 5, 6}
    result := slice.UniqueBy(nums, func(val int) int {
        return val % 3
    })

    fmt.Println(result)

    // Output:
    // [1 2 0]
}

Union

Creates a slice of unique values, in order, from all given slices. using == for equality comparisons.

Signature:

func Union[T comparable](slices ...[]T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums1 := []int{1, 3, 4, 6}
    nums2 := []int{1, 2, 5, 6}

    result := slice.Union(nums1, nums2)

    fmt.Println(result)

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

UnionBy

UnionBy is like Union, what's more it accepts iteratee which is invoked for each element of each slice.

Signature:

func UnionBy[T any, V comparable](predicate func(item T) V, slices ...[]T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    nums := []int{1, 2, 3, 4}

    divideTwo := func(n int) int {
        return n / 2
    }
    result := slice.UnionBy(divideTwo, nums)

    fmt.Println(result)

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

UpdateAt

Update the slice element at index. if param index < 0 or index >= len(slice), will return error.

Signature:

func UpdateAt[T any](slice []T, index int, value T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result1 := slice.UpdateAt([]string{"a", "b", "c"}, -1, "1")
    result2 := slice.UpdateAt([]string{"a", "b", "c"}, 0, "1")
    result3 := slice.UpdateAt([]string{"a", "b", "c"}, 1, "1")
    result4 := slice.UpdateAt([]string{"a", "b", "c"}, 2, "1")
    result5 := slice.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]
}

Without

Creates a slice excluding all given items.

Signature:

func Without[T comparable](slice []T, items ...T) []T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result := slice.Without([]int{1, 2, 3, 4}, 1, 2)

    fmt.Println(result)

    // Output:
    // [3 4]
}

KeyBy

Converts a slice to a map based on a callback function.

Signature:

func KeyBy[T any, U comparable](slice []T, iteratee func(item T) U) map[U]T

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/v2/slice"
)

func main() {
    result := slice.KeyBy([]string{"a", "ab", "abc"}, func(str string) int {
        return len(str)
    })

    fmt.Println(result)

    // Output:
    // map[1:a 2:ab 3:abc]
}

31 KiB Raw Blame History

Slice

Source:

Usage:

Index

Documentation

AppendIfAbsent

Contain

ContainSubSlice

Chunk

Compact

Concat

Count

CountBy

Difference

DifferenceBy

DifferenceWith

DeleteAt

Drop

Equal

EqualWith

Every

Filter

Find

FindLast

Flatten

FlattenDeep

ForEach

GroupBy

GroupWith

IntSlice (Deprecated: use generic feature of go1.18+ for replacement)

InterfaceSlice (Deprecated: use generic feature of go1.18+ for replacement)

Intersection

InsertAt

IndexOf

LastIndexOf

Map

Merge

Reverse

Reduce

Replace

ReplaceAll

Repeat

Shuffle

Sort

SortBy

SortByField (Deprecated: use Sort and SortBy for replacement)

Some

StringSlice (Deprecated: use generic feature of go1.18+ for replacement)

SymmetricDifference

ToSlice

ToSlicePointer

Unique

UniqueBy

Union

UnionBy

UpdateAt

Without

KeyBy

31 KiB

Raw Blame History