sliceKit

package
v2.0.16 Latest Latest
Warning

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

 Go to latest Published: May 15, 2023 License: Apache-2.0 Imports: 8 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 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 浅克隆（浅拷贝）

参考: golang复制切片的方法（避免操作同一底层数组） https://blog.csdn.net/weixin_43970884/article/details/126051345

@param src 可以为nil @return 保底为len==0的slice实例

e.g. 浅拷贝 

s0 := []string{"0", "1", "2"}
s1 := sliceKit.Copy(s0)

s1[0] = "3"
fmt.Println(s0) // [0 1 2]
fmt.Println(s1) // [3 1 2]

e.g.1 传参为nil 

s := sliceKit.Copy([]int(nil))
fmt.Println(s)        // []
fmt.Println(len(s))   // 0
fmt.Println(s != nil) // true

func Copy1 deprecated 

func Copy1[T any](src []T) []T

Copy1 浅克隆（浅拷贝）

Deprecated: 并不是我想要的"浅拷贝".

e.g. 

s0 := []string{"0", "1", "2"}
s1 := sliceKit.Copy1(s0)

s1[0] = "3"
fmt.Println(s0) // [3 1 2]
fmt.Println(s1) // [3 1 2]

func Copy2 deprecated 

func Copy2[T any](src []T) []T

Copy2 浅克隆（浅拷贝）

Deprecated: 并不是我想要的"浅拷贝".

e.g. 

s0 := []string{"0", "1", "2"}
s1 := sliceKit.Copy2(s0)

s1[0] = "3"
fmt.Println(s0) // [3 1 2]
fmt.Println(s1) // [3 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 DeepCopy 

func DeepCopy[T any](src []T) ([]T, error)

DeepCopy 深拷贝

e.g. 

([]string(nil)) => (nil, nil)

e.g.1 

s := []*Bean{{Id: 0}, {Id: 1}}
s1, err := sliceKit.DeepCopy(s)
if err != nil {
	panic(err)
}

fmt.Printf("%p\n", &s)   // 0x1400000c048
fmt.Printf("%p\n", s[0]) // 0x140000220a0
fmt.Printf("%p\n", s[1]) // 0x140000220a8

fmt.Println("==================")

fmt.Printf("%p\n", &s1)   // 0x1400000c060
fmt.Printf("%p\n", s1[0]) // 0x140000220b0
fmt.Printf("%p\n", s1[1]) // 0x140000220d8

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, len(s))] @param to 取值范围: [0, len(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 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[T constraints.Ordered](s []T, descArgs ...bool) []T

Sort （简单数据类型）排序

@param s 可以为nil，将返回nil @param descArgs true: 降序 

false: 升序（默认）

@return 可能为nil

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

func SortComplexSlice 

func SortComplexSlice(data sort.Interface, args ...bool) sort.Interface

SortComplexSlice 排序复杂类型的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，将返回nil @param args true: 稳定; false: 不稳定（默认；大部分场景这就够了） @return 可能为nil

e.g. s := []int{0, 2, 3, 1} sliceKit.SortComplexSlice(sort.IntSlice(s)) fmt.Println(s) // [0 1 2 3]

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.