sliceKit

package
v3.0.66 Latest Latest
Warning

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

 Go to latest Published: Apr 22, 2024 License: Apache-2.0 Imports: 14 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var Join func(s []string, sep string) string = strings.Join

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 AssertNotEmpty 

func AssertNotEmpty[T any](s []T, name string) error

AssertNotEmpty

合法的传参: (1) s != nil (2) len(s) > 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 

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

ContainsBy

@param s 可以为nil（返回false） @param predicate 不能为nil， (1) 如果返回true，本函数直接返回true（即包含）; 

(2) 否则判断切片中的下一个元素.

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

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 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 DeepCopy 

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

DeepCopy 深拷贝

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 Each 

func Each[T any](collection []T, iteratee func(item T, index int) bool)

Each 遍历（可以中断）.

@param iteratee (1) 返回true，中断遍历； 

(2) 返回false，继续遍历.

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 遍历（不可中断）.

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 

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

ForEachInParallel 遍历（内部是for range + goroutine，遍历前会拷贝一份s然后遍历它）.

PS: 多协程，并发.

@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 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 

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 (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 

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

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 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 LastIndexOf 

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

LastIndexOf

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

func LinearSearch 

func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int

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 

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

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 

func SortStably(data sort.Interface)

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

func Split 

func Split[T any](buf []T, limit int) [][]T

Split 分割 []E

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

type SliceWithLock 

type SliceWithLock[E any] struct {
	mutexKit.RWMutex

	// Slice 并发不安全的
	Slice []E
}

func NewSliceWithLock 

func NewSliceWithLock[E any]() *SliceWithLock[E]

func (*SliceWithLock[E]) Size 

func (s *SliceWithLock[E]) Size() (size int)

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.