当前切片中不包含值时，将该值追加到切片中
函数签名: ```go func AppendIfAbsent[T comparable](slice []T, item T) []T ``` 示例:[运行](https://go.dev/play/p/GNdv7Jg2Taj) ```go 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判断slice是否包含value
函数签名: ```go func Contain[T comparable](slice []T, target T) bool ``` 示例:[运行](https://go.dev/play/p/_454yEHcNjf) ```go 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 } ``` ### ContainBy根据predicate函数判断切片是否包含某个值。
函数签名: ```go func ContainBy[T any](slice []T, predicate func(item T) bool) bool ``` 示例:[运行](https://go.dev/play/p/49tkHfX4GNc) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { type foo struct { A string B int } array1 := []foo{{A: "1", B: 1}, {A: "2", B: 2}} result1 := slice.ContainBy(array1, func(f foo) bool { return f.A == "1" && f.B == 1 }) result2 := slice.ContainBy(array1, func(f foo) bool { return f.A == "2" && f.B == 1 }) array2 := []string{"a", "b", "c"} result3 := slice.ContainBy(array2, func(t string) bool { return t == "a" }) result4 := slice.ContainBy(array2, func(t string) bool { return t == "d" }) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) fmt.Println(result4) // Output: // true // false // true // false } ``` ### ContainSubSlice判断slice是否包含subslice
函数签名: ```go func ContainSubSlice[T comparable](slice, subSlice []T) bool ``` 示例:[运行](https://go.dev/play/p/bcuQ3UT6Sev) ```go 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按照size参数均分slice
函数签名: ```go func Chunk[T any](slice []T, size int) [][]T ``` 示例:[运行](https://go.dev/play/p/b4Pou5j2L_C) ```go 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去除slice中的假值（false values are false, nil, 0, ""）
函数签名: ```go func Compact[T comparable](slice []T) []T ``` 示例:[运行](https://go.dev/play/p/pO5AnxEr3TK) ```go 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创建一个新的切片，将传入的切片拼接起来返回。
函数签名: ```go func Concat[T any](slices ...[]T) []T ``` 示例:[运行](https://go.dev/play/p/gPt-q7zr5mk) ```go 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返回切片中指定元素的个数
函数签名: ```go func Count[T comparable](slice []T, item T) int ``` 示例:[运行](https://go.dev/play/p/Mj4oiEnQvRJ) ```go 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遍历切片，对每个元素执行函数predicate. 返回符合函数返回值为true的元素的个数.
函数签名: ```go func CountBy[T any](slice []T, predicate func(index int, item T) bool) int ``` 示例:[运行](https://go.dev/play/p/tHOccTMDZCC) ```go 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创建一个切片，其元素不包含在另一个给定切片中
函数签名: ```go func Difference[T comparable](slice, comparedSlice []T) []T ``` 示例:[运行](https://go.dev/play/p/VXvadzLzhDa) ```go 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将两个slice中的每个元素调用iteratee函数，并比较它们的返回值，如果不相等返回在slice中对应的值
函数签名: ```go func DifferenceBy[T comparable](slice []T, comparedSlice []T, iteratee func(index int, item T) T) []T ``` 示例:[运行](https://go.dev/play/p/DiivgwM5OnC) ```go 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接受比较器函数，该比较器被调用以将切片的元素与值进行比较。 结果值的顺序和引用由第一个切片确定
函数签名: ```go func DifferenceWith[T any](slice []T, comparedSlice []T, comparator func(value, otherValue T) bool) []T ``` 示例:[运行](https://go.dev/play/p/v2U2deugKuV) ```go 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删除切片中指定索引的元素（不修改原切片）。
函数签名: ```go func DeleteAt[T any](slice []T, index int) []T ``` 示例:[运行](https://go.dev/play/p/800B1dPBYyd) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { chars := []string{"a", "b", "c", "d", "e"} result1 := slice.DeleteAt(chars, 0) result2 := slice.DeleteAt(chars, 4) result3 := slice.DeleteAt(chars, 5) result4 := slice.DeleteAt(chars, 6) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) fmt.Println(result4) // Output: // [b c d e] // [a b c d] // [a b c d] // [a b c d] } ``` ### DeleteRange删除切片中指定索引范围的元素（不修改原切片）。
函数签名: ```go func DeleteRange[T any](slice []T, start, end int) []T ``` 示例:[运行](https://go.dev/play/p/945HwiNrnle) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { chars := []string{"a", "b", "c", "d", "e"} result1 := DeleteRange(chars, 0, 0) result2 := DeleteRange(chars, 0, 1) result3 := DeleteRange(chars, 0, 3) result4 := DeleteRange(chars, 0, 4) result5 := DeleteRange(chars, 0, 5) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) fmt.Println(result4) fmt.Println(result5) // Output: // [a b c d e] // [b c d e] // [d e] // [e] // [] } ``` ### Drop从切片的头部删除n个元素。
函数签名: ```go func Drop[T any](slice []T, n int) []T ``` 示例:[运行](https://go.dev/play/p/jnPO2yQsT8H) ```go 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 c] // [] } ``` ### DropRight从切片的尾部删除n个元素。
函数签名: ```go func DropRight[T any](slice []T, n int) []T ``` 示例:[运行](https://go.dev/play/p/8bcXvywZezG) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { result1 := slice.DropRight([]string{"a", "b", "c"}, 0) result2 := slice.DropRight([]string{"a", "b", "c"}, 1) result3 := slice.DropRight([]string{"a", "b", "c"}, -1) result4 := slice.DropRight([]string{"a", "b", "c"}, 4) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) fmt.Println(result4) // Output: // [a b c] // [a b] // [a b c] // [] } ``` ### DropWhile从切片的头部删除n个元素，这个n个元素满足predicate函数返回true。
函数签名: ```go func DropWhile[T any](slice []T, predicate func(item T) bool) []T ``` 示例:[运行](https://go.dev/play/p/4rt252UV_qs) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { result1 := slice.DropWhile(numbers, func(n int) bool { return n != 2 }) result2 := slice.DropWhile(numbers, func(n int) bool { return true }) result3 := slice.DropWhile(numbers, func(n int) bool { return n == 0 }) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) // Output: // [2 3 4 5] // [] // [1 2 3 4 5] } ``` ### DropRightWhile从切片的尾部删除n个元素，这个n个元素满足predicate函数返回true。
函数签名: ```go func DropRightWhile[T any](slice []T, predicate func(item T) bool) []T ``` 示例:[运行](https://go.dev/play/p/6wyK3zMY56e) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { numbers := []int{1, 2, 3, 4, 5} result1 := slice.DropRightWhile(numbers, func(n int) bool { return n != 2 }) result2 := slice.DropRightWhile(numbers, func(n int) bool { return true }) result3 := slice.DropRightWhile(numbers, func(n int) bool { return n == 0 }) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) // Output: // [1 2] // [] // [1 2 3 4 5] } ``` ### Every如果切片中的所有值都通过谓词函数，则返回true。 函数签名应该是func(index int, value any) bool
函数签名: ```go func Every[T any](slice []T, predicate func(index int, item T) bool) bool ``` 示例:[运行](https://go.dev/play/p/R8U6Sl-j8cD) ```go 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 } ``` ### Equal检查两个切片是否相等，相等条件：切片长度相同，元素顺序和值都相同
函数签名: ```go func Equal[T comparable](slice1, slice2 []T) bool ``` 示例:[运行](https://go.dev/play/p/WcRQJ37ifPa) ```go 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检查两个切片是否相等，相等条件：对两个切片的元素调用比较函数comparator，返回true
函数签名: ```go func EqualWith[T, U any](slice1 []T, slice2 []U, comparator func(T, U) bool) bool ``` 示例:[运行](https://go.dev/play/p/b9iygtgsHI1) ```go 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 } ``` ### Filter返回切片中通过predicate函数真值测试的所有元素
函数签名: ```go func Filter[T any](slice []T, predicate func(index int, item T) bool) []T ``` 示例:[运行](https://go.dev/play/p/SdPna-7qK4T) ```go 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] } ``` ### FilterConcurrent对slice并发执行filter操作。
函数签名: ```go func FilterConcurrent[T any](slice []T, predicate func(index int, item T) bool, numThreads int) []T ``` 示例:[运行](https://go.dev/play/p/t_pkwerIRVx) ```go 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.FilterConcurrent(nums, isEven, 2) fmt.Println(result) // Output: // [2 4] } ``` ### Find遍历slice的元素，返回第一个通过predicate函数真值测试的元素
> ⚠️ 本函数已弃用，使用`FindBy`代替。 函数签名: ```go func Find[T any](slice []T, predicate func(index int, item T) bool) (*T, bool) ``` 示例:[运行](https://go.dev/play/p/CBKeBoHVLgq) ```go 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 } ``` ### FindBy遍历slice的元素，返回第一个通过predicate函数真值测试的元素
函数签名: ```go func FindBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool) ``` 示例:[运行](https://go.dev/play/p/n1lysBYl-GB) ```go 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.FindBy(nums, isEven) fmt.Println(result) fmt.Println(ok) // Output: // 2 // true } ``` ### FindLast遍历slice的元素，返回最后一个通过predicate函数真值测试的元素。
> ⚠️ 本函数已弃用，使用`FindLastBy`代替。 函数签名: ```go func FindLast[T any](slice []T, predicate func(index int, item T) bool) (*T, bool) ``` 示例:[运行](https://go.dev/play/p/FFDPV_j7URd) ```go 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 } ``` ### FindLastBy从遍历slice的元素，返回最后一个通过predicate函数真值测试的元素。
函数签名: ```go func FindLastBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool) ``` 示例:[运行](https://go.dev/play/p/8iqomzyCl_s) ```go 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.FindLastBy(nums, isEven) fmt.Println(result) fmt.Println(ok) // Output: // 4 // true } ``` ### Flatten将切片压平一层
函数签名: ```go func Flatten(slice any) any ``` 示例:[运行](https://go.dev/play/p/hYa3cBEevtm) ```go 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]] } ``` ### FlattenDeepflattens slice recursive.
函数签名: ```go func FlattenDeep(slice any) any ``` 示例:[运行](https://go.dev/play/p/yjYNHPyCFaF) ```go 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遍历切片的元素并为每个元素调用iteratee函数
函数签名: ```go func ForEach[T any](slice []T, iteratee func(index int, item T)) ``` 示例:[运行](https://go.dev/play/p/DrPaa4YsHRF) ```go 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] } ``` ### ForEachConcurrent对slice并发执行foreach操作。
函数签名: ```go func ForEachConcurrent[T any](slice []T, iteratee func(index int, item T), numThreads int) ``` 示例:[运行](https://go.dev/play/p/kT4XW7DKVoV) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { nums := []int{1, 2, 3, 4, 5, 6, 7, 8} result := make([]int, len(nums)) addOne := func(index int, value int) { result[index] = value + 1 } slice.ForEachConcurrent(nums, addOne, 4) fmt.Println(result) // Output: // [2 3 4 5 6 7 8 9] } ``` ### ForEachWithBreak遍历切片的元素并为每个元素调用iteratee函数，当iteratee函数返回false时，终止遍历。
函数签名: ```go func ForEachWithBreak[T any](slice []T, iteratee func(index int, item T) bool) ``` 示例:[运行](https://go.dev/play/p/qScs39f3D9W) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { numbers := []int{1, 2, 3, 4, 5} var sum int slice.ForEachWithBreak(numbers, func(_, n int) bool { if n > 3 { return false } sum += n return true }) fmt.Println(sum) // Output: // 6 } ``` ### GroupBy迭代切片的元素，每个元素将按条件分组，返回两个切片
函数签名: ```go func GroupBy[T any](slice []T, groupFn func(index int, item T) bool) ([]T, []T) ``` 示例:[运行](https://go.dev/play/p/QVkPxzPR0iA) ```go 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创建一个map，key是iteratee遍历slice中的每个元素返回的结果。 分组值的顺序是由他们出现在slice中的顺序确定的。每个键对应的值负责生成key的元素组成的数组。iteratee调用1个参数： (value)
函数签名: ```go func GroupWith[T any, U comparable](slice []T, iteratee func(T) U) map[U][]T ``` 示例:[运行](https://go.dev/play/p/ApCvMNTLO8a) ```go 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将接口切片转换为int切片
> ⚠️ 本函数已弃用，使用go1.18+泛型代替。 函数签名: ```go func IntSlice(slice any) []int ``` 示例:[运行](https://go.dev/play/p/UQDj-on9TGN) ```go 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将值转换为接口切片
> ⚠️ 本函数已弃用，使用go1.18+泛型代替。 函数签名: ```go func InterfaceSlice(slice any) []any ``` 示例:[运行](https://go.dev/play/p/FdQXF0Vvqs-) ```go 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多个切片的交集
函数签名: ```go func Intersection[T comparable](slices ...[]T) []T ``` 示例:[运行](https://go.dev/play/p/anJXfB5wq_t) ```go 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将元素插入到索引处的切片中
函数签名: ```go func InsertAt[T any](slice []T, index int, value any) []T ``` 示例:[运行](https://go.dev/play/p/hMLNxPEGJVE) ```go 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返回在切片中找到值的第一个匹配项的索引，如果找不到值，则返回-1
函数签名: ```go func IndexOf[T comparable](slice []T, item T) int ``` 示例:[运行](https://go.dev/play/p/MRN1f0FpABb) ```go 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返回在切片中找到最后一个值的索引，如果找不到该值，则返回-1
函数签名: ```go func LastIndexOf[T comparable](slice []T, item T) int ``` 示例:[运行](https://go.dev/play/p/DokM4cf1IKH) ```go 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对slice中的每个元素执行map函数以创建一个新切片。
函数签名: ```go func Map[T any, U any](slice []T, iteratee func(index int, item T) U) []U ``` 示例:[运行](https://go.dev/play/p/biaTefqPquw) ```go 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] } ``` ### MapConcurrent对slice并发执行map操作。
函数签名: ```go func MapConcurrent[T any, U any](slice []T, iteratee func(index int, item T) U, numThreads int) []U ``` 示例:[运行](https://go.dev/play/p/H1ehfPkPen0) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { nums := []int{1, 2, 3, 4, 5, 6} result := slice.MapConcurrent(nums, func(_, n int) int { return n * n }, 4) fmt.Println(result) // Output: // [1 4 9 16 25 36] } ``` ### FilterMap返回一个将filter和map操作应用于给定切片的切片。 iteratee回调函数应该返回两个值：1，结果值。2，结果值是否应该被包含在返回的切片中。
函数签名: ```go func FilterMap[T any, U any](slice []T, iteratee func(index int, item T) (U, bool)) []U ``` 示例:[运行](https://go.dev/play/p/J94SZ_9MiIe) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { nums := []int{1, 2, 3, 4, 5} getEvenNumStr := func(i, num int) (string, bool) { if num%2 == 0 { return strconv.FormatInt(int64(num), 10), true } return "", false } result := slice.FilterMap(nums, getEvenNumStr) fmt.Printf("%#v", result) // Output: // []string{"2", "4"} } ``` ### FlatMap将切片转换为其它类型切片。
函数签名: ```go func FlatMap[T any, U any](slice []T, iteratee func(index int, item T) []U) []U ``` 示例:[运行](https://go.dev/play/p/_QARWlWs1N_F) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { nums := []int{1, 2, 3, 4} result := slice.FlatMap(nums, func(i int, num int) []string { s := "hi-" + strconv.FormatInt(int64(num), 10) return []string{s} }) fmt.Printf("%#v", result) // Output: // []string{"hi-1", "hi-2", "hi-3", "hi-4"} } ``` ### Merge合并多个切片（不会消除重复元素).
> ⚠️ 本函数已弃用，使用`Concat`代替。 函数签名: ```go func Merge[T any](slices ...[]T) []T ``` 示例:[运行](https://go.dev/play/p/lbjFp784r9N) ```go 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反转切片中的元素顺序
函数签名: ```go func Reverse[T any](slice []T) ``` 示例:[运行](https://go.dev/play/p/8uI8f1lwNrQ) ```go 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将切片中的元素依次运行iteratee函数，返回运行结果。
> ⚠️ 本函数已弃用，使用`ReduceBy`代替。 函数签名: ```go func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initial T) T ``` 示例:[运行](https://go.dev/play/p/_RfXJJWIsIm) ```go 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 } ``` ### ReduceConcurrent对切片元素执行并发reduce操作。
函数签名: ```go func ReduceConcurrent[T any](slice []T, initial T, reducer func(index int, item T, agg T) T, numThreads int) T ``` 示例:[运行](https://go.dev/play/p/Tjwe6OtaG07) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} result := slice.ReduceConcurrent(nums, 0, func(_ int, item, agg int) int { return agg + item }, 1) fmt.Println(result) // Output: // 55 } ``` ### ReduceBy对切片元素执行reduce操作。
函数签名: ```go func ReduceBy[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U ``` 示例:[运行](https://go.dev/play/p/YKDpLi7gtee) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { result1 := slice.ReduceBy([]int{1, 2, 3, 4}, 0, func(_ int, item int, agg int) int { return agg + item }) result2 := slice.ReduceBy([]int{1, 2, 3, 4}, "", func(_ int, item int, agg string) string { return agg + fmt.Sprintf("%v", item) }) fmt.Println(result1) fmt.Println(result2) // Output: // 10 // 1234 } ``` ### ReduceRight类似ReduceBy操作，迭代切片元素顺序从右至左。
函数签名: ```go func ReduceRight[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U ``` 示例:[运行](https://go.dev/play/p/qT9dZC03A1K) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { result := slice.ReduceRight([]int{1, 2, 3, 4}, "", func(_ int, item int, agg string) string { return agg + fmt.Sprintf("%v", item) }) fmt.Println(result) // Output: // 4321 } ``` ### Replace返回切片的副本，其中前n个不重叠的old替换为new
函数签名: ```go func Replace[T comparable](slice []T, old T, new T, n int) []T ``` 示例:[运行](https://go.dev/play/p/P5mZp7IhOFo) ```go 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返回切片的副本，将其中old全部替换为new
函数签名: ```go func ReplaceAll[T comparable](slice []T, old T, new T) []T ``` 示例:[运行](https://go.dev/play/p/CzqXMsuYUrx) ```go 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创建一个切片，包含n个传入的item
函数签名: ```go func Repeat[T any](item T, n int) []T ``` 示例:[运行](https://go.dev/play/p/1CbOmtgILUU) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { result := slice.Repeat("a", 3) fmt.Println(result) // Output: // [a a a] } ``` ### Shuffle随机打乱切片中的元素顺序
函数签名: ```go func Shuffle[T any](slice []T) []T ``` 示例:[运行](https://go.dev/play/p/YHvhnWGU3Ge) ```go 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) } ``` ### IsAscending检查切片元素是否按升序排列。
函数签名: ```go func IsAscending[T constraints.Ordered](slice []T) bool ``` 示例:[运行](https://go.dev/play/p/9CtsFjet4SH) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { result1 := slice.IsAscending([]int{1, 2, 3, 4, 5}) result2 := slice.IsAscending([]int{5, 4, 3, 2, 1}) result3 := slice.IsAscending([]int{2, 1, 3, 4, 5}) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) // Output: // true // false // false } ``` ### IsDescending检查切片元素是否按降序排列。
函数签名: ```go func IsDescending[T constraints.Ordered](slice []T) bool ``` 示例:[运行](https://go.dev/play/p/U_LljFXma14) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { result1 := slice.IsDescending([]int{5, 4, 3, 2, 1}) result2 := slice.IsDescending([]int{1, 2, 3, 4, 5}) result3 := slice.IsDescending([]int{2, 1, 3, 4, 5}) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) // Output: // true // false // false } ``` ### IsSorted检查切片元素是否是有序的（升序或降序）。
函数签名: ```go func IsSorted[T constraints.Ordered](slice []T) bool ``` 示例:[运行](https://go.dev/play/p/nCE8wPLwSA-) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { result1 := slice.IsSorted([]int{5, 4, 3, 2, 1}) result2 := slice.IsSorted([]int{1, 2, 3, 4, 5}) result3 := slice.IsSorted([]int{2, 1, 3, 4, 5}) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) // Output: // true // true // false } ``` ### IsSortedByKey通过iteratee函数，检查切片元素是否是有序的。
函数签名: ```go func IsSortedByKey[T any, K constraints.Ordered](slice []T, iteratee func(item T) K) bool ``` 示例:[运行](https://go.dev/play/p/tUoGB7DOHI4) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { result1 := slice.IsSortedByKey([]string{"a", "ab", "abc"}, func(s string) int { return len(s) }) result2 := slice.IsSortedByKey([]string{"abc", "ab", "a"}, func(s string) int { return len(s) }) result3 := slice.IsSortedByKey([]string{"abc", "a", "ab"}, func(s string) int { return len(s) }) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) // Output: // true // true // false } ``` ### Sort对任何有序类型（数字或字符串）的切片进行排序，使用快速排序算法。 默认排序顺序为升序 (asc)，如果需要降序，请将参数 `sortOrder` 设置为 `desc`。 Ordered类型：数字（所有整数浮点数）或字符串。
函数签名: ```go func Sort[T constraints.Ordered](slice []T, sortOrder ...string) ``` 示例:[运行](https://go.dev/play/p/V9AVjzf_4Fk) ```go 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按照less函数确定的升序规则对切片进行排序。排序不保证稳定性
函数签名: ```go func SortBy[T any](slice []T, less func(a, b T) bool) ``` 示例:[运行](https://go.dev/play/p/DAhLQSZEumm) ```go 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按字段对结构体切片进行排序。slice元素应为struct，排序字段field类型应为int、uint、string或bool。 默认排序类型是升序（asc），如果是降序，设置 sortType 为 desc
函数签名: ```go func SortByField(slice any, field string, sortType ...string) error ``` 示例:[运行](https://go.dev/play/p/fU1prOBP9p1) ```go 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如果列表中的任何值通过谓词函数，则返回true
函数签名: ```go func Some[T any](slice []T, predicate func(index int, item T) bool) bool ``` 示例:[运行](https://go.dev/play/p/4pO9Xf9NDGS) ```go 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将接口切片转换为字符串切片
> ⚠️ 本函数已弃用，使用go1.18+泛型代替。 函数签名: ```go func StringSlice(slice any) []string ``` 示例:[运行](https://go.dev/play/p/W0TZDWCPFcI) ```go 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返回一个切片，其中的元素存在于参数切片中，但不同时存储在于参数切片中（交集取反）
函数签名: ```go func SymmetricDifference[T comparable](slices ...[]T) []T ``` 示例:[运行](https://go.dev/play/p/1CbOmtgILUU) ```go 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将可变参数转为切片
函数签名: ```go func ToSlice[T any](items ...T) []T ``` 示例:[运行](https://go.dev/play/p/YzbzVq5kscN) ```go 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将可变参数转为指针切片
函数签名: ```go func ToSlicePointer[T any](items ...T) []*T ``` 示例:[运行](https://go.dev/play/p/gx4tr6_VXSF) ```go 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删除切片中的重复元素
函数签名: ```go func Unique[T comparable](slice []T) []T ``` 示例:[运行](https://go.dev/play/p/AXw0R3ZTE6a) ```go 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根据迭代函数返回的值，从输入切片中移除重复元素。此函数保持元素的顺序。
函数签名: ```go func UniqueBy[T any, U comparable](slice []T, iteratee func(item T) U) []T ``` 示例:[运行](https://go.dev/play/p/GY7JE4yikrl) ```go 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 3] } ``` ### UniqueByComparator使用提供的比较器函数从输入切片中移除重复元素。此函数保持元素的顺序。
函数签名: ```go func UniqueByComparator[T comparable](slice []T, comparator func(item T, other T) bool) []T ``` 示例:[运行](https://go.dev/play/p/rwSacr-ZHsR) ```go import ( "fmt" "github.com/duke-git/lancet/slice" ) func main() { uniqueNums := slice.UniqueByComparator([]int{1, 2, 3, 1, 2, 4, 5, 6, 4}, func(item int, other int) bool { return item == other }) caseInsensitiveStrings := slice.UniqueByComparator([]string{"apple", "banana", "Apple", "cherry", "Banana", "date"}, func(item string, other string) bool { return strings.ToLower(item) == strings.ToLower(other) }) fmt.Println(uniqueNums) fmt.Println(caseInsensitiveStrings) // Output: // [1 2 3 4 5 6] // [apple banana cherry date] } ``` ### UniqueByConcurrent并发的从输入切片中移除重复元素，结果保持元素的顺序。
函数签名: ```go func UniqueByConcurrent[T comparable](slice []T, comparator func(item T, other T) bool, numThreads int) []T ``` 示例:[运行](https://go.dev/play/p/wXZ7LcYRMGL) ```go import ( "fmt" "github.com/duke-git/lancet/slice" ) func main() { nums := []int{1, 2, 3, 1, 2, 4, 5, 6, 4, 7} comparator := func(item int, other int) bool { return item == other } result := slice.UniqueByConcurrent(nums, comparator, 4) fmt.Println(result) // Output: // [1 2 3 4 5 6 7] } ``` ### UniqueByField根据struct字段对struct切片去重复。
函数签名: ```go func UniqueByField[T any](slice []T, field string) ([]T, error) ``` 示例:[运行](https://go.dev/play/p/6cifcZSPIGu) ```go import ( "fmt" "github.com/duke-git/lancet/slice" ) func main() { type User struct { ID int `json:"id"` Name string `json:"name"` } users := []User{ {ID: 1, Name: "a"}, {ID: 2, Name: "b"}, {ID: 1, Name: "c"}, } result, err := slice.UniqueByField(users, "ID") if err != nil { } fmt.Println(result) // Output: // [{1 a} {2 b}] } ``` ### Union合并多个切片
函数签名: ```go func Union[T comparable](slices ...[]T) []T ``` 示例:[运行](https://go.dev/play/p/hfXV1iRIZOf) ```go 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对切片的每个元素调用函数后，合并多个切片
函数签名: ```go func UnionBy[T any, V comparable](predicate func(item T) V, slices ...[]T) []T ``` 示例:[运行](https://go.dev/play/p/HGKHfxKQsFi) ```go 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更新索引处的切片元素。 如果index < 0或 index <= len(slice)，将返回错误
函数签名: ```go func UpdateAt[T any](slice []T, index int, value T) []T ``` 示例:[运行](https://go.dev/play/p/f3mh2KloWVm) ```go 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创建一个不包括所有给定值的切片
函数签名: ```go func Without[T comparable](slice []T, items ...T) []T ``` 示例:[运行](https://go.dev/play/p/bwhEXEypThg) ```go 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将切片每个元素调用函数后转为map。
函数签名: ```go func KeyBy[T any, U comparable](slice []T, iteratee func(item T) U) map[U]T ``` 示例:[运行](https://go.dev/play/p/uXod2LWD1Kg) ```go 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] } ``` ### Join用指定的分隔符链接切片元素。
函数签名: ```go func Join[T any](s []T, separator string) string ``` 示例:[运行](https://go.dev/play/p/huKzqwNDD7V) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { nums := []int{1, 2, 3, 4, 5} result1 := slice.Join(nums, ",") result2 := slice.Join(nums, "-") fmt.Println(result1) fmt.Println(result2) // Output: // 1,2,3,4,5 // 1-2-3-4-5 } ``` ### Partition根据给定的predicate判断函数分组切片元素。
函数签名: ```go func Partition[T any](slice []T, predicates ...func(item T) bool) [][]T ``` 示例:[运行](https://go.dev/play/p/lkQ3Ri2NQhV) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { nums := []int{1, 2, 3, 4, 5} result1 := slice.Partition(nums) result2 := slice.Partition(nums, func(n int) bool { return n%2 == 0 }) result3 := slice.Partition(nums, func(n int) bool { return n == 1 || n == 2 }, func(n int) bool { return n == 2 || n == 3 || n == 4 }) fmt.Println(result1) fmt.Println(result2) fmt.Println(result3) // Output: // [[1 2 3 4 5]] // [[2 4] [1 3 5]] // [[1 2] [3 4] [5]] } ``` ### Random随机返回切片中元素以及下标, 当切片长度为0时返回下标-1
函数签名: ```go func Random[T any](slice []T) (val T, idx int) ``` 示例:[运行](https://go.dev/play/p/UzpGQptWppw) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { nums := []int{1, 2, 3, 4, 5} val, idx := slice.Random(nums) if idx >= 0 && idx < len(nums) && slice.Contain(nums, val) { fmt.Println("okk") } // Output: // okk } ``` ### SetToDefaultIf根据给定给定的predicate判定函数来修改切片中的元素。对于满足的元素，将其替换为指定的默认值，同时保持元素在切片中的位置不变。函数返回修改后的切片以及被修改的元素个数。
函数签名: ```go func SetToDefaultIf[T any](slice []T, predicate func(T) bool) ([]T, int) ``` 示例:[运行](https://go.dev/play/p/9AXGlPRC0-A) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { strs := []string{"a", "b", "a", "c", "d", "a"} modifiedStrs, count := slice.SetToDefaultIf(strs, func(s string) bool { return "a" == s }) fmt.Println(modifiedStrs) fmt.Println(count) // Output: // [ b c d ] // 3 } ``` ### Break根据判断函数将切片分成两部分。它开始附加到与函数匹配的第一个元素之后的第二个切片。第一个匹配之后的所有元素都包含在第二个切片中，无论它们是否与函数匹配。
函数签名: ```go func Break[T any](values []T, predicate func(T) bool) ([]T, []T) ``` 示例:[运行](https://go.dev/play/p/yLYcBTyeQIz) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { nums := []int{1, 2, 3, 4, 5} even := func(n int) bool { return n%2 == 0 } resultEven, resultAfterFirstEven := slice.Break(nums, even) fmt.Println(resultEven) fmt.Println(resultAfterFirstEven) // Output: // [1] // [2 3 4 5] } ``` ### RightPadding在切片的右部添加元素。
函数签名: ```go func RightPadding[T any](slice []T, paddingValue T, paddingLength int) []T ``` 示例:[运行](https://go.dev/play/p/0_2rlLEMBXL) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { nums := []int{1, 2, 3, 4, 5} padded := slice.RightPadding(nums, 0, 3) fmt.Println(padded) // Output: // [1 2 3 4 5 0 0 0] } ``` ### LeftPadding在切片的左部添加元素。
函数签名: ```go func LeftPadding[T any](slice []T, paddingValue T, paddingLength int) []T ``` 示例:[运行](https://go.dev/play/p/jlQVoelLl2k) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { nums := []int{1, 2, 3, 4, 5} padded := slice.LeftPadding(nums, 0, 3) fmt.Println(padded) // Output: // [0 0 0 1 2 3 4 5] } ``` ### Frequency计算切片中每个元素出现的频率。
函数签名: ```go func Frequency[T comparable](slice []T) map[T]int ``` 示例:[运行](https://go.dev/play/p/CW3UVNdUZOq) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { strs := []string{"a", "b", "b", "c", "c", "c"} result := slice.Frequency(strs) fmt.Println(result) // Output: // map[a:1 b:2 c:3] } ``` ### JoinFunc将切片元素用给定的分隔符连接成一个单一的字符串。
函数签名: ```go func JoinFunc[T any](slice []T, sep string, transform func(T) T) string ``` 示例:[运行](https://go.dev/play/p/55ib3SB5fM2) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { result := slice.JoinFunc([]string{"a", "b", "c"}, ", ", func(s string) string { return strings.ToUpper(s) }) fmt.Println(result) // Output: // A, B, C } ``` ### ConcatBy将切片中的元素连接成一个值，使用指定的分隔符和连接器函数。
函数签名: ```go func ConcatBy[T any](slice []T, sep T, connector func(T, T) T) T ``` 示例:[运行](https://go.dev/play/p/6QcUpcY4UMW) ```go import ( "fmt" "github.com/duke-git/lancet/v2/slice" ) func main() { type Person struct { Name string Age int } people := []Person{ {Name: "Alice", Age: 30}, {Name: "Bob", Age: 25}, {Name: "Charlie", Age: 35}, } sep := Person{Name: " | ", Age: 0} personConnector := func(a, b Person) Person { return Person{Name: a.Name + b.Name, Age: a.Age + b.Age} } result := slice.ConcatBy(people, sep, personConnector) fmt.Println(result.Name) fmt.Println(result.Age) // Output: // Alice | Bob | Charlie // 90 } ```