Documentation
¶
Index ¶
- Variables
- func Append[T any](s []T, eles ...T) []Tdeprecated
- func AssertNotEmpty[T any](s []T, name string) error
- func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, ...) int
- func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, ...) int
- func BubbleSort[T any](slice []T, comparator constraints.Comparator)
- func Clear[T any](s []T)
- func Compact[T comparable](s []T) []T
- func Contains[T comparable](s []T, element T) bool
- func ContainsBy[T any](s []T, predicate func(item T) bool) bool
- func ContainsStringIgnoreCase(s []string, str string) bool
- func ConvertElementType[T any, R any](s []T, iteratee func(item T, index int) R) []R
- func ConvertElementTypeInParallel[T any, R any](s []T, iteratee func(item T, index int) R) []R
- func Copy[T any](s []T) []T
- func CopyToDest[T any](src, dest []T) int
- func Count[T comparable](collection []T, value T) (count int)
- func CountBy[T any](collection []T, predicate func(item T) bool) (count int)
- func CountSort[T any](slice []T, comparator constraints.Comparator) []T
- func CountValues[T comparable](collection []T) map[T]int
- func CountValuesBy[T any, U comparable](collection []T, mapper func(item T) U) map[U]int
- func DeepCopy[T any](s []T) []T
- func Drop[T any](collection []T, n int) []T
- func DropRight[T any](collection []T, n int) []T
- func DropRightWhile[T any](collection []T, predicate func(item T) bool) []T
- func DropWhile[T any](collection []T, predicate func(item T) bool) []T
- func Each[T any](collection []T, iteratee func(item T, index int) bool)
- func EmptyToNil[T any](s []T) []T
- func Filter[V any](s []V, predicate func(item V, index int) bool) []V
- func FilterAndRevise[T any, R any](s []T, callback func(item T, index int) (R, bool)) []R
- func Find[T any](s []T, predicate func(item T) bool) (T, bool)
- func FindIndexOf[T any](s []T, predicate func(item T) bool) (T, int, bool)
- func FindLastIndexOf[T any](s []T, predicate func(item T) bool) (T, int, bool)
- func FindOrElse[T any](s []T, fallback T, predicate func(item T) bool) T
- func ForEach[T any](s []T, iteratee func(item T, index int))
- func ForEachInParallel[T any](s []T, iteratee func(item T, index int))
- func Get[T any](s []T, index int) Tdeprecated
- func GetFirstItemWithDefault[T any](def T, args ...T) T
- func Group[T any, U comparable](s []T, iteratee func(item T) U) map[U][]T
- func GroupInParallel[T any, U comparable](s []T, iteratee func(item T) U) map[U][]T
- func HeapSort[T any](slice []T, comparator constraints.Comparator)
- func IndexOf[T comparable](s []T, element T) int
- func InsertionSort[T any](slice []T, comparator constraints.Comparator)
- func Intercept[T any](s []T, from, to int, maxArgs ...int) []T
- func InterceptAfter[T any](s []T, index int) []T
- func InterceptBefore[T any](s []T, index int) []T
- func IsEmpty[T any](s []T) bool
- func IsNotEmpty[T any](s []T) bool
- func IsSorted[T constraints.Ordered](s []T) bool
- func IsSortedByKey[T any, K constraints.Ordered](s []T, iteratee func(item T) K) bool
- func LastIndexOf[T comparable](s []T, element T) int
- func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int
- func Merge[T comparable](slices ...[]T) []T
- func MergeSort[T any](slice []T, comparator constraints.Comparator)
- func QuickSort[T any](slice []T, comparator constraints.Comparator)
- func Range[T constraints.Integer | constraints.Float](start T, count int) []T
- func RangeWithStep[T constraints.Integer | constraints.Float](start, end, step T) []T
- func Reduce[T any, R any](s []T, accumulator func(agg R, item T, index int) R, initial R) R
- func ReduceRight[T any, R any](s []T, accumulator func(agg R, item T, index int) R, initial R) R
- func Remove[T comparable](s []T, item T) ([]T, bool)
- func RemoveBy[T comparable](s []T, predicate func(element T) bool) []T
- func RemoveByIndex[T any](s []T, index int) (s1 []T, item T, ok bool)
- func RemoveEmpty(s []string, trimArgs ...bool) []string
- func RemoveFirst[T any](s []T) (s1 []T, item T, ok bool)
- func RemoveLast[T any](s []T) (s1 []T, item T, ok bool)
- func Replace[T comparable](collection []T, old T, new T, n int) []T
- func ReplaceAll[T comparable](collection []T, old T, new T) []T
- func Reverse[T any](s []T) []Tdeprecated
- func SelectionSort[T any](slice []T, comparator constraints.Comparator)
- func ShellSort[T any](slice []T, comparator constraints.Comparator)
- func Shuffle[T any](s []T) []T
- func SimpleSort[T constraints.Ordered](s []T)
- func SimpleSortByDesc[T constraints.Ordered](s []T)
- func SliceToMap[T any, K comparable, V any](s []T, transform func(item T) (K, V)) map[K]V
- func Sort(data sort.Interface)
- func SortStably(data sort.Interface)
- func Split[T any](buf []T, limit int) [][]T
- func Swap[T any](s []T, i, j int)
- func ToString[T any](s []T) string
- func Uniq[T comparable](s []T) []T
- func UniqBy[T any, U comparable](collection []T, iteratee func(item T) U) []T
- type RemoveJudge
- type SliceWithLock
Constants ¶
This section is empty.
Variables ¶
Join []string => string
@param sep 分隔符
e.g. (nil, "-") => "" ([]string{}, "-") => "" e.g.1 ([]string{"1"}, ";") => "1" ([]string{"0", "1", "2", "3", ""}, "-") => "0-1-2-3-"
Functions ¶
func Append
deprecated
func Append[T any](s []T, eles ...T) []T
Append 向slice实例的"最后面"添加元素
Deprecated: 考虑性能的场景下,不建议直接调用此方法(此方法仅供展示传参规范).
PS: (1) 传参s == nil的情况下,此时如果eles数量>=1,将返回1个非nil的slice实例,否则将返回nil. (2) append()返回的是1个新的slice实例.
@param s 可以为nil @return 可能为nil
e.g. ([]string(nil)) => nil ([]string(nil), []string(nil)...) => nil ([]string(nil), "0") => []string{"0"}
func BinaryIterativeSearch ¶
func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator constraints.Comparator) int
BinaryIterativeSearch 二分迭代查找,返回元素索引,未找到元素返回-1,参数comparator需要实现包constraints.Comparator。
func BinarySearch ¶
func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator constraints.Comparator) int
BinarySearch (二分法)二分递归查找,返回元素索引,未找到元素返回-1,参数comparator需要实现包constraints.Comparator。
func BubbleSort ¶
func BubbleSort[T any](slice []T, comparator constraints.Comparator)
BubbleSort 冒泡排序,参数comparator需要实现包constraints.Comparator。
func Clear ¶
func Clear[T any](s []T)
Clear 保持slice的长度(len)和容量(cap),但将所有slice内已存在的元素(len个)都置为元素类型的零值.
func Compact ¶
func Compact[T comparable](s []T) []T
Compact 去除零值.
@param s 可以为nil;不会修改传参s @return 必定不为nil(保底为空的slice实例)
e.g.
s := []string{"", "foo", "", "bar", ""} s1 := sliceKit.Compact[string](s) fmt.Println(s1) // [foo bar]
func Contains ¶
func Contains[T comparable](s []T, element T) bool
Contains
@param s 可以为nil(返回false)
func ContainsBy ¶
ContainsBy
@param s 可以为nil(返回false) @param predicate 不能为nil, (1) 如果返回true,本函数直接返回true(即包含);
(2) 否则判断切片中的下一个元素.
func ContainsStringIgnoreCase ¶
ContainsStringIgnoreCase 字符串str是否在切片s中?(不区分大小写)
func ConvertElementType ¶
ConvertElementType 转换切片实例的元素类型
@param string 可以为nil @param iteratee 不能为nil,会导致panic: runtime error: invalid memory address or nil pointer dereference @return 必定不为nil(保底空的slice实例)
e.g. []int => []string
s := sliceKit.ConvertElementType([]int{0, 1, 2, 3}, func(item int, index int) string { return "0x" + strconv.Itoa(item) }) fmt.Println(s) // [0x0 0x1 0x2 0x3]
func ConvertElementTypeInParallel ¶
ConvertElementTypeInParallel 转换切片实例的元素类型
PS: 使用协程更加高效,但要慎用!!!
@param string 可以为nil @param iteratee 不能为nil,会导致panic: runtime error: invalid memory address or nil pointer dereference @return 必定不为nil(保底空的slice实例)
func Copy ¶
func Copy[T any](s []T) []T
Copy 浅拷贝(浅克隆)
PS: 也可以使用 copyKit.Copy(). 参考: golang复制切片的方法(避免操作同一底层数组) https://blog.csdn.net/weixin_43970884/article/details/126051345
@param src 可以为nil(此时将返回空的slice实例) @return != nil
e.g.
src := []string{"0", "1", "2"} dest := sliceKit.Copy(src) src[0] = "a" fmt.Println(src) // [a 1 2] fmt.Println(dest) // [0 1 2]
func CopyToDest ¶
CopyToDest 将src的元素复制到dest中(可能会修改dest的内容,但dest的内存地址不变!!!)
PS: (1) src和dest中只要有一个为nil(包括两个都为nil的情况),返回值必定为0 && 不会修改dest; (2) src和dest都不为nil的情况下,len(src) <= len(dest),复制 src的前n个元素 并用他们覆盖 dest的前n个元素(n == len(src),可能为0); (3) src和dest都不为nil的情况下,len(src) > len(dest),复制 src的前n个元素 并用他们覆盖 dest的前n个元素(n == len(dest),可能为0).
@param src 可以为nil @param dest 可以为nil @return 被复制的元素的个数(即len(src)和len(dest)间的最小值;>= 0)
e.g. nil的情况 [byte](nil, nil) => 0 [byte]([]byte("abc"), nil) => 0 [byte](nil, []byte("abcde")) => 0 e.g.1 正常情况 ([]byte("012"), []byte("abcde")) => 3(dest变为[]byte("012de")) ([]byte("01234"), []byte("abc")) => 3(dest变为[]byte("012"))
func Count ¶
func Count[T comparable](collection []T, value T) (count int)
Count
e.g.
count := lo.Count([]int{1, 5, 1}, 1) // 2
func CountBy ¶
CountBy
e.g.
count := lo.CountBy([]int{1, 5, 1}, func(i int) bool { return i < 4 }) // 2
func CountSort ¶
func CountSort[T any](slice []T, comparator constraints.Comparator) []T
CountSort 计数排序,参数comparator需要实现包constraints.Comparator。
func CountValues ¶
func CountValues[T comparable](collection []T) map[T]int
CountValues 计算集合中每个元素的个数.
e.g.
lo.CountValues([]int{1, 2, 2}) // map[int]int{1: 1, 2: 2}
func CountValuesBy ¶
func CountValuesBy[T any, U comparable](collection []T, mapper func(item T) U) map[U]int
CountValuesBy
e.g.
isEven := func(v int) bool { return v%2==0 } lo.CountValuesBy([]int{1, 2, 2}, isEven) // map[bool]int{false: 1, true: 2}
func Drop ¶
Drop 从"左"开始,丢弃n个数据
@param collection (1) 可以为nil
(2) 不会修改传参collection
@param n 丢弃数据的个数 @return 非nil的slice实例(len >= 0)
e.g. 不会修改传参collection
s := []int{0, 1, 2, 3, 4, 5} s1 := sliceKit.Drop(s, 2) fmt.Println(s) // [0 1 2 3 4 5] fmt.Println(s1) // [2 3 4 5] s1[0] = 9 fmt.Println(s) // [0 1 2 3 4 5] fmt.Println(s1) // [9 3 4 5]
func DropRightWhile ¶
DropRightWhile
@param collection (1)可以为nil (2)此传参不会被修改 @return 不为nil,len >= 0
e.g.
s := []string{"a", "aa", "aaa", "aa", "aa"} s1 := sliceKit.DropRightWhile(s, func(val string) bool { return len(val) <= 2 }) fmt.Println(s) // [a aa aaa aa aa] fmt.Println(s1) // [aaa aa aa]
func DropWhile ¶
DropWhile
@param collection (1)可以为nil (2)此传参不会被修改 @return 不为nil,len >= 0
e.g.
s := []string{"a", "aa", "aaa", "aa", "aa"} s1 := sliceKit.DropWhile(s, func(val string) bool { return len(val) <= 2 }) fmt.Println(s) // [a aa aaa aa aa] fmt.Println(s1) // [aaa aa aa]
func EmptyToNil ¶
func EmptyToNil[T any](s []T) []T
func Filter ¶
Filter 过滤.
@param s (1) 可以为nil
(2) 不会修改传参s
@param predicate (1) true: 该元素加到返回的slice实例中
(2) 不能为nil,会导致panic: runtime error: invalid memory address or nil pointer dereference
@return 必定不为nil(保底为空的slice实例)
e.g.
s := sliceKit.Filter([]int{0, 1, 2, 3}, func(item int, index int) bool { return item >= 2 }) fmt.Println(s) // [2 3]
func FilterAndRevise ¶
FilterAndRevise 过滤(可额外处理满足条件的元素).
@param s 可以为nil @param callback (1) 不能为nil
(2) 第2个返回值: 是否满足过滤条件? (3) 第2个返回值 == true的情况下,将第1个返回值加到返回的slice实例中.
@return 必定不为nil(保底为空的slice实例)
e.g.
s := sliceKit.FilterAndRevise([]string{"cpu", "gpu", "mouse", "keyboard"}, func(item string, index int) (string, bool) { if strings.HasSuffix(item, "pu") { return "right-" + item, true } return "", false }) fmt.Println(s) // [right-cpu right-gpu]
func FindIndexOf ¶
FindIndexOf
@param s 可以为nil @param predicate 返回true: 该元素是要找的 @param 如果找不到,第2个返回值为-1
func FindLastIndexOf ¶
FindLastIndexOf
@param s 可以为nil @param predicate 返回true: 该元素是要找的 @param 如果找不到,第2个返回值为-1
func FindOrElse ¶
FindOrElse
@param s 可以为nil @param fallback 默认值(找不到就返回它) @param predicate 返回true: 该元素是要找的
func ForEach ¶
ForEach 遍历(不可中断).
PS: 内部是for range,遍历前会拷贝一份s然后遍历它
@param s 可以为nil @param iteratee 不能为nil
e.g.
s := []int{0, 1, 2} fmt.Println(s) // [0 1 2] sliceKit.ForEach(s, func(item int, index int) { s[index] = item + 1 }) fmt.Println(s) // [1 2 3]
func ForEachInParallel ¶
ForEachInParallel 遍历(内部是for range + goroutine,遍历前会拷贝一份s然后遍历它).
PS: 多协程,并发.
@param s 可以为nil @param iteratee 不能为nil
func GetFirstItemWithDefault ¶
func GetFirstItemWithDefault[T any](def T, args ...T) T
GetFirstItemWithDefault 主要用于: 从不定参数(...)中取第一个值(不存在则取默认值)
PS: (1) 因为Golang不支持方法重载; (2) T类型值可能为nil的情况,要注意防坑.
@param args 要么是: nil;要么是: 长度>=1的切片实例
func Group ¶
func Group[T any, U comparable](s []T, iteratee func(item T) U) map[U][]T
Group 分组
PS: 不会修改传参s.
@param s 可以为nil @param iteratee 不能为nil @return 保底为空的map实例
e.g.
s := []int{0, 1, 2, 3, 4, 5} m := sliceKit.Group[int, int](s, func(i int) int { return i % 3 }) fmt.Println(s) // [0 1 2 3 4 5] fmt.Println(m) // map[0:[0 3] 1:[1 4] 2:[2 5]]
func GroupInParallel ¶
func GroupInParallel[T any, U comparable](s []T, iteratee func(item T) U) map[U][]T
func HeapSort ¶
func HeapSort[T any](slice []T, comparator constraints.Comparator)
HeapSort 堆排序,参数comparator需要实现包constraints.Comparator。
func IndexOf ¶
func IndexOf[T comparable](s []T, element T) int
IndexOf
@param s 可以为nil(此时返回-1) @return 如果不存在于切片实例中的话,返回-1
func InsertionSort ¶
func InsertionSort[T any](slice []T, comparator constraints.Comparator)
InsertionSort 插入排序,参数comparator需要实现包constraints.Comparator。
func Intercept ¶
Intercept 截取 [from, to)
参考: golang2021数据格式(23)切片截取 https://baijiahao.baidu.com/s?id=1711198159326157378
PS: (1) 不存在越界 && s != nil(包括len(s) == 0) 的情况下,如果from == to,将返回空的slice实例(非nil). (2) from > to || 下标越界,会导致 panic: runtime error: slice bounds out of range [1:0]
@param s 可以为nil(将返回nil) @param from 取值范围: [0, cap(s))] @param to 取值范围: [0, cap(s))] @return (1) 可能为nil(当传参s为nil时)
(2) 返回值不涉及深浅拷贝,修改会导致"同步修改"
e.g. 返回值不涉及深浅拷贝,修改会导致"同步修改"
s := []int{0, 1, 2, 3} s1 := s[1:] fmt.Println(s, unsafe.Pointer(&s)) // [0 1 2 3] 0x140000a0018 fmt.Println(s1, unsafe.Pointer(&s1)) // [1 2 3] 0x140000a0030 s1[2] = 9 fmt.Println(s, unsafe.Pointer(&s)) // [0 1 2 9] 0x140000a0018 fmt.Println(s1, unsafe.Pointer(&s1)) // [1 2 9] 0x140000a0030
e.g.1 不存在越界的情况下,如果from == to,将返回空的slice实例(非nil).
s := []int{0, 1, 2} s1 := sliceKit.Intercept(s, len(s), len(s)) fmt.Println(s1) // [] fmt.Println(s1 != nil) // true
e.g.2
var s []int = []int{} s1 := sliceKit.Intercept(s, 0, 0) fmt.Println(s1) fmt.Println(s1 != nil)
func InterceptAfter ¶
InterceptAfter
@param s 可以为nil @param index 取值范围: [0, length] @return (1) 必定非nil
(2) [index, length) (3) s为空,返回: s (4) s非空 && index == 0,返回: s (5) s非空 && index == length,返回: [](空)
e.g.
s := []int{1} fmt.Println(sliceKit.InterceptAfter(s, 0)) // [1] fmt.Println(sliceKit.InterceptAfter(s, 1)) // []
func InterceptBefore ¶
InterceptBefore
@param s 可以为nil @param index 取值范围: [0, length] @return (1) 必定非nil && length >= 0
(2) [0, index) (3) s为空,返回: s (4) s非空 && index == 0,返回: [](空) (5) s非空 && index == length,返回: s
e.g.
s := []int{1} fmt.Println(sliceKit.InterceptBefore(s, 0)) // [] fmt.Println(sliceKit.InterceptBefore(s, 1)) // [1]
func IsSorted ¶
func IsSorted[T constraints.Ordered](s []T) bool
IsSorted 传参切片实例是否有序?
@param s (1) 可以为nil
(2) 如果 len(s) <= 1 ,返回值一定为true
e.g. [int](nil) => true ([]string{}) => true ([]string{"b"}) => true ([]string{"b", "a"}) => false ([]int{0, 1, 9, 100}) => true
func IsSortedByKey ¶
func IsSortedByKey[T any, K constraints.Ordered](s []T, iteratee func(item T) K) bool
IsSortedByKey 传参切片实例是否有序?
@param s (1) 可以为nil
(2) 如果 len(s) <= 1 ,返回值一定为true
e.g.
flag := sliceKit.IsSortedByKey([]string{"a", "aa", "bb", "ccc"}, func(s string) int { return len(s) }) fmt.Println(flag) // true
func LastIndexOf ¶
func LastIndexOf[T comparable](s []T, element T) int
LastIndexOf
@param s 可以为nil(此时返回-1) @return 如果不存在于切片实例中的话,返回-1
func LinearSearch ¶
LinearSearch 基于传入的相等函数线性查找元素,返回元素索引,未找到元素返回-1。
func Merge ¶
func Merge[T comparable](slices ...[]T) []T
Merge 合并多个切片(不会去重)
PS: (1) 先要传参nil的话,必须要造型. e.g. []string(nil) (2) 第1个传参可以为nil
@return 可能为nil
e.g.
s := sliceKit.Merge[string](nil, []string{}) fmt.Println(s) // [] fmt.Println(len(s)) // 0 fmt.Println(s != nil) // true
e.g.1
([]string(nil), []string{"1", "2"}) => [1 2] ([]string{"1", "2"}, []string(nil)) => [1 2] ([]string(nil)) => nil ([]string{}) => [] ([]string(nil), []string{"a", "b"}, []string(nil), []string{"b", "c"}) => [a b b c]
func MergeSort ¶
func MergeSort[T any](slice []T, comparator constraints.Comparator)
MergeSort 归并排序,参数comparator需要实现包constraints.Comparator。
func QuickSort ¶
func QuickSort[T any](slice []T, comparator constraints.Comparator)
QuickSort 快速排序,参数comparator需要实现包constraints.Comparator。
func Range ¶
func Range[T constraints.Integer | constraints.Float](start T, count int) []T
Range 根据指定的起始值和数量,创建一个数字切片(step为1)。
e.g.
fmt.Println(sliceKit.Range(-4, 4)) // [-4 -3 -2 -1]
func RangeWithStep ¶
func RangeWithStep[T constraints.Integer | constraints.Float](start, end, step T) []T
RangeWithStep 根据指定的起始值,结束值,步长,创建一个数字切片。
e.g.
fmt.Println(sliceKit.RangeWithStep(-4, 1, 2)) // [-4 -2 0]
func Reduce ¶
Reduce 将slice实例归纳为一个值(从左到右遍历).
PS: 排除骚操作,不会修改传参s.
@param s 可以为nil @param accumulator 不能为nil @param initial 初始值
func ReduceRight ¶
ReduceRight 将slice实例归纳为一个值(从右到左遍历;和 Reduce 相反).
PS: 排除骚操作,不会修改传参s.
@param s 可以为nil @param accumulator 不能为nil @param initial 初始值
func Remove ¶
func Remove[T comparable](s []T, item T) ([]T, bool)
Remove 移除元素.
PS: (1) 切片实例s中,存在多个item的话,仅会移除第一个.
@param s (1)可以为nil (2)不会修改传参s
e.g. 反例
texts := []string{"0", "1", "2"} fmt.Println(texts) // [0 1 2] texts1, _ := sliceKit.Remove(texts, "1") fmt.Println(texts) // [0 2 2] fmt.Println(texts1) // [0 2]
func RemoveBy ¶
func RemoveBy[T comparable](s []T, predicate func(element T) bool) []T
RemoveBy 移除不满足条件的元素(返回的是一个新的slice实例).
@param s 可以为nil @param predicate (1)不能为nil (2)返回值为true: 移除当前元素 @return (1)非nil (2)len>=0
func RemoveByIndex ¶
RemoveByIndex 根据下标删除指定元素.
PS: (0) 也可以用于移除"第一个"或"最后一个"个元素; (1) 为什么要有两个返回值且第一个是slice?因为 append() 并不会修改传参slice,返回的是一个新的slice. (2) 调用此方法后,必须第一时间将 第一个返回值 赋值给 传进来的那个slice变量!!!
@param s (1) 可以为nil
(2) 不会修改传参s
@param index 下标(索引),取值范围: [0, length)
e.g.
s := []int{0, 1, 2, 3} s1, item, ok := sliceKit.RemoveByIndex(s, 2) fmt.Println(s) // [0 1 2 3] fmt.Println(s1) // [0 1 3] fmt.Println(item) // 2 fmt.Println(ok) // true
func RemoveEmpty ¶
RemoveEmpty
@param trimArgs 是否 先 对每个元素进行trim操作?默认:false
e.g. (nil) => nil ([]string{""}) => []string{}
func RemoveFirst ¶
RemoveFirst 移除第一个元素(如果有的话)
@param s 可以为nil
e.g. [int](nil) => [] 0 false ([]int{0}) => [] 0 true ([]int{0, 1}) => [1] 0 true
func RemoveLast ¶
RemoveLast 移除最后一个元素(如果有的话)
@param s 可以为nil
e.g. [int](nil) => [] 0 false ([]int{0}) => [] 0 true ([]int{0, 1}) => [0] 1 true
func Replace ¶
func Replace[T comparable](collection []T, old T, new T, n int) []T
Replace
@param collection 可以为nil @param n 替换的个数(如果有这么多的话)
(1) > 0,替换指定个数 (2) = 0,一个都不替换 (3) < 0,替换所有
@return 保底为length==0的切片实例
e.g. # 替换0个 ([]int{0, 1, 2, 2, 3, 3, 3}, 2, 9, 0) => [0 1 2 2 3 3 3] # 替换2个 ([]int{0, 1, 2, 2, 3, 3, 3}, 3, 9, 2) => [0 1 2 2 9 9 3] # 替换所有 ([]int{0, 1, 2, 2, 3, 3, 3}, 3, 9, -1) => [0 1 2 2 9 9 9]
func ReplaceAll ¶
func ReplaceAll[T comparable](collection []T, old T, new T) []T
ReplaceAll 替换所有.
@param collection 可以为nil @return 保底为length==0的切片实例
func SelectionSort ¶
func SelectionSort[T any](slice []T, comparator constraints.Comparator)
SelectionSort 选择排序,参数comparator需要实现包constraints.Comparator。
func ShellSort ¶
func ShellSort[T any](slice []T, comparator constraints.Comparator)
ShellSort 希尔排序,参数comparator需要实现包constraints.Comparator。
func Shuffle ¶
func Shuffle[T any](s []T) []T
Shuffle 随机打乱切片.
PS: 会改变传参s的内容.
@param s 可以为nil
e.g. [string](nil) => nil []string{"0", "1", "2", "3"} => [2 0 3 1]
func SimpleSort ¶
func SimpleSort[T constraints.Ordered](s []T)
SimpleSort (升序)排序
@param s 可以为nil
e.g.
s := []int{9, 0, -1, 1} sliceKit.SimpleSort(s) fmt.Println(s) // [-1 0 1 9]
func SimpleSortByDesc ¶
func SimpleSortByDesc[T constraints.Ordered](s []T)
SimpleSortByDesc (降序)排序
@param s 可以为nil
e.g.
s := []int{9, 0, -1, 1} sliceKit.SimpleSortByDesc(s) fmt.Println(s) // [9 1 0 -1]
func SliceToMap ¶
func SliceToMap[T any, K comparable, V any](s []T, transform func(item T) (K, V)) map[K]V
SliceToMap slice实例 => map实例
@param s 可以为nil @param transform 不能为nil(除非s == nil),否则会导致panic: runtime error: invalid memory address or nil pointer dereference @return 必定不为nil(保底为空的map实例)
e.g.
m := sliceKit.SliceToMap[string, string, string]([]string{"0", "1"}, func(item string) (string, string) { return "key" + item, "value" + item }) fmt.Println(m) // map[key0:value0 key1:value1]
func Sort ¶
Sort 排序复杂类型的slice实例(元素的类型可以为自定义结构体)
PS: (1) 需要注意的是 sort.Sort() 函数不能保证数据排序是稳定的,
如果需要保证数据排序稳定,可以使用 sort.Stable() 函数。(“稳定”的含义是原始数据中 a 和 b 的值相等,排序前 a 排在 b 的前面,排序后 a 仍排在 b 的前面)
(2) 现成的sort.Interface接口的实现: sort.IntSlice、sort.Float64Slice、sort.StringSlice.
@param data 可以为nil
func SortStably ¶
SortStably 类似于 Sort,区别: SortStably 能保证数据排序是稳定的.
func Swap ¶
Swap 交换切片实例中两个元素的值
PS: (1)传参s不能为nil,会panic(下标越界); (2)此方法会修改传参s(虽然golang是值传递); (3)传参i、j:下标越界会导致panic.
@param s 不能为nil @param i 第1个元素的下标(从0开始) @param j 第2个元素的下标(从0开始)
e.g.
s := []int{1, 0, 100} sliceKit.Swap(s, 0, 2) fmt.Println(s) // [100 0 1]
func ToString ¶
ToString 切片实例(元素任意类型) => string
参考: https://mp.weixin.qq.com/s/tvy9L-pb_8WFWAmA9u-bMg
e.g. ([]int{-1, 0, 1}) => "[-1 0 1]"
func Uniq ¶
func Uniq[T comparable](s []T) []T
Uniq 去重.
PS: 不会修改传参s.
@param s 可以为nil @return 必定不为nil(保底为空的slice实例)
e.g.
s := sliceKit.Uniq([]interface{}{0, 1, 2, 0, "1", "2", "1"}) fmt.Println(s) // [0 1 2 1 2](前3个为int类型,后2个为string类型)
func UniqBy ¶
func UniqBy[T any, U comparable](collection []T, iteratee func(item T) U) []T
UniqBy
PS: 不会修改传参s.
@param s 可以为nil @param iteratee 不能为nil @return 必定不为nil(保底为空的slice实例)
e.g.
s0 := []int{0, 1, 2, 3, 4, 5} s1 := sliceKit.UniqBy[int, int](s0, func(i int) int { return i % 3 }) fmt.Println(s0) // [0 1 2 3 4 5] fmt.Println(s1) // [0 1 2]
Types ¶
type RemoveJudge ¶
type RemoveJudge[T comparable] func(ele T) (remove bool, interrupt bool)
RemoveJudge 判断是否将元素从slice中移除
@param ele slice中的1个元素 @return remove 是否将该元素移除? @return interrupt 是否中断遍历?
type SliceWithLock ¶
func NewSliceWithLock ¶
func NewSliceWithLock[E any]() *SliceWithLock[E]
func (*SliceWithLock[E]) Size ¶
func (s *SliceWithLock[E]) Size() (size int)