sliceKit

package
v2.0.18 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: May 26, 2023 License: Apache-2.0 Imports: 9 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

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 AssertNotEmpty added in v2.0.17

func AssertNotEmpty[T any](s []T) error

AssertNotEmpty

合法的传参: (1) s != nil (2) len(s) > 0

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

func ContainsBy[T any](s []T, predicate func(item T) bool) bool

ContainsBy

@param s 可以为nil(返回false) @param predicate 不能为nil

func ContainsStringIgnoreCase

func ContainsStringIgnoreCase(s []string, str string) bool

ContainsStringIgnoreCase 字符串str是否在切片s中?(不区分大小写)

func ConvertElementType

func ConvertElementType[T any, R any](s []T, iteratee func(item T, index int) R) []R

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

func ConvertElementTypeInParallel[T any, R any](s []T, iteratee func(item T, index int) R) []R

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](src []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

func CopyToDest[T any](src, dest []T) int

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

func CountBy[T any](collection []T, predicate func(item T) bool) (count int)

CountBy

e.g.

count := lo.CountBy([]int{1, 5, 1}, func(i int) bool {
	return i < 4
})
// 2

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

func Drop[T any](collection []T, n int) []T

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 DropRight

func DropRight[T any](collection []T, n int) []T

DropRight 从"右"开始,丢弃n个数据

e.g. ([]int{0, 1, 2, 3, 4, 5}, 2) => []int{0, 1, 2, 3}

func DropRightWhile

func DropRightWhile[T any](collection []T, predicate func(item T) bool) []T

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

func DropWhile[T any](collection []T, predicate func(item T) bool) []T

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

func Filter[V any](s []V, predicate func(item V, index int) bool) []V

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

func FilterAndRevise[T any, R any](s []T, callback func(item T, index int) (R, bool)) []R

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 Find

func Find[T any](s []T, predicate func(item T) bool) (T, bool)

Find

@param s 可以为nil @param predicate 返回true: 该元素是要找的 @return 第2个返回值: 是否找到?

func FindIndexOf

func FindIndexOf[T any](s []T, predicate func(item T) bool) (T, int, bool)

FindIndexOf

@param s 可以为nil @param predicate 返回true: 该元素是要找的 @param 如果找不到,第2个返回值为-1

func FindLastIndexOf

func FindLastIndexOf[T any](s []T, predicate func(item T) bool) (T, int, bool)

FindLastIndexOf

@param s 可以为nil @param predicate 返回true: 该元素是要找的 @param 如果找不到,第2个返回值为-1

func FindOrElse

func FindOrElse[T any](s []T, fallback T, predicate func(item T) bool) T

FindOrElse

@param s 可以为nil @param fallback 默认值(找不到就返回它) @param predicate 返回true: 该元素是要找的

func ForEach

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

ForEach 遍历

@param s 可以为nil @param iteratee 不能为nil

func ForEachInParallel

func ForEachInParallel[T any](s []T, iteratee func(item T, index int))

ForEachInParallel 遍历

!!!: 多协程,并发.

@param s 可以为nil @param iteratee 不能为nil

func Get deprecated

func Get[T any](s []T, index int) T

Get 根据下标获取slice中的元素

Deprecated: 考虑性能的场景下,不建议直接调用此方法(此方法仅供展示传参规范).

PS: (1) 如果s == nil,会导致panic;(不管index为何值,即使为0) (2) 如果s != nil && len(s) == 0,会导致panic;(不管index为何值,即使为0) (3) 如果s != nil && len(s) > 0,index的取值范围: [0, length).

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 IndexOf

func IndexOf[T comparable](s []T, element T) int

IndexOf

@param s 可以为nil(此时返回-1) @return 如果不存在于切片实例中的话,返回-1

func Intercept

func Intercept[T any](s []T, from, to int, maxArgs ...int) []T

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

func InterceptAfter[T any](s []T, index int) []T

InterceptAfter

@param s 可以为nil @param index 取值范围: [0, length] @return [index, length)

func InterceptBefore

func InterceptBefore[T any](s []T, index int) []T

InterceptBefore

@param s 可以为nil @param index 取值范围: [0, length] @return [0, index)

func IsEmpty

func IsEmpty[T any](s []T) bool

IsEmpty

@param s 可以为nil

func IsNotEmpty

func IsNotEmpty[T any](s []T) bool

IsNotEmpty

@param s 可以为nil

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 Join

func Join(s []string, sep string) string

Join []string => string

@param sep 分隔符

e.g. (nil, "-") => "" ([]string{}, "-") => "" ([]string{"0", "1", "2", "3"}, "-") => "0-1-2-3"

func LastIndexOf

func LastIndexOf[T comparable](s []T, element T) int

LastIndexOf

@param s 可以为nil(此时返回-1) @return 如果不存在于切片实例中的话,返回-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. ([]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 Reduce

func Reduce[T any, R any](s []T, accumulator func(agg R, item T, index int) R, initial R) R

Reduce 将slice实例归纳为一个值(从左到右遍历).

PS: 排除骚操作,不会修改传参s.

@param s 可以为nil @param accumulator 不能为nil @param initial 初始值

func ReduceRight

func ReduceRight[T any, R any](s []T, accumulator func(agg R, item T, index int) R, initial R) R

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

func RemoveByIndex[T any](s []T, index int) (s1 []T, item T, ok bool)

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

func RemoveEmpty(s []string, trimArgs ...bool) []string

RemoveEmpty

@param trimArgs 是否 先 对每个元素进行trim操作?默认:false

e.g. (nil) => nil ([]string{""}) => []string{}

func RemoveFirst

func RemoveFirst[T any](s []T) (s1 []T, item T, ok bool)

RemoveFirst 移除第一个元素(如果有的话)

@param s 可以为nil

e.g. [int](nil) => [] 0 false ([]int{0}) => [] 0 true ([]int{0, 1}) => [1] 0 true

func RemoveLast

func RemoveLast[T any](s []T) (s1 []T, item T, ok bool)

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 Reverse deprecated

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

Reverse 反转切片.

Deprecated: This helper is mutable. This behavior might change in v2.0.0.

@param s (1)可以为nil (2)可能会改变传参s的内容. @return 可能为nil

e.g. (nil) => nil ([]string{"0", "1", "2", "3"}) => [3 2 1 0]

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 added in v2.0.17

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 added in v2.0.17

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

func Sort(data sort.Interface)

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 added in v2.0.17

func SortStably(data sort.Interface)

SortStably 类似于 Sort,区别: SortStably 能保证数据排序是稳定的.

func Swap

func Swap[T any](s []T, i, j int)

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

func ToString[T any](s []T) string

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	是否中断遍历?

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL