Documentation
¶
Index ¶
- Variables
- func All[S ~[]T, T any](fun func(x T) bool, arr S) bool
- func Any[S ~[]T, T any](fun func(x T) bool, arr S) bool
- func ArrSequenceCount[A ~[]T, T gotools.Comparable](arr1 A, arr2 A) int
- func Cartesian[S ~[]T, T any](arr ...S) [][]T
- func Choose[S ~[]T, T any](index []int, arr S) []T
- func Chunk[S ~[]T, T any](size int, arr S) [][]T
- func Compact[S ~[]T, T gotools.Comparable](arr S) []T
- func CompactAny[S ~[]T, T any](fun func(x, y T) bool, arr S) []T
- func Concat[S ~[]T, T any](a, b S) []T
- func Copy[T any](arr []T) []T
- func CopyWithNum[T any](arr []T, num int) []T
- func Count[S ~[]T, T any](arr S) int
- func CountIf[S ~[]T, T any](fun func(x T) bool, arr S) int
- func Difference[S ~[]T, T gotools.Number](arr S) []T
- func Distinct[S ~[]T, T gotools.Comparable](arr S) []T
- func DistinctCount[S ~[]T, T gotools.Comparable](arr S) int
- func EnumerateDense[S ~[]T, T gotools.Comparable](arr S) []int
- func Fill[S ~[]T, T any](fun func(x T) bool, arr S) []T
- func Filter[S ~[]T, T any](fun func(x T) bool, arr S) []T
- func FilterIndex[S ~[]T, T any](fun func(x T) bool, arr S) []int
- func FindFirst[S ~[]T, T any](fun func(x T) bool, arr S) int
- func FindLast[S ~[]T, T any](fun func(x T) bool, arr S) int
- func FindMax[S ~[]T, T gotools.Ordered](arr S) int
- func FindMin[S ~[]T, T gotools.Ordered](arr S) int
- func First[S ~[]T, T any](fun func(x T) bool, arr S) T
- func FlatMap[S ~[]T, T any, U any](fun func(x T) []U, arr S) []U
- func From[T any](input ...T) []T
- func FromConvert[T, U any](fun func(T) U, input ...T) []U
- func FromIf[T any](fun func(T any) bool, input ...T) []T
- func Has[S ~[]T, T gotools.Comparable](arr S, elem T) bool
- func HasAll[S ~[]T, T gotools.Comparable](arr S, elems ...T) bool
- func HasAny[S ~[]T, T gotools.Comparable](arr S, elems ...T) bool
- func HasDupMaxCount[S ~[]T, T gotools.Comparable](source, match S) int
- func HasIncreaseMaxCount[S ~[]T, T gotools.Comparable](source, match S) int
- func HasOrderMaxCount[S ~[]T, T gotools.Comparable](source, match S, exist map[T]struct{}) int
- func HasSequence[A ~[]T, T gotools.Comparable](arr1 A, arr2 A) (bool, int)
- func InsertAt[S ~[]T, T any](data S, pos ...int) func(default_x T) []T
- func InterS[S ~[]T, T gotools.Comparable](a, b S) []T
- func Intersect[S ~[]T, T any, U gotools.Comparable](f func(x T) U, a, b S) []T
- func Lag[T any](arr []T, n int, def T) []T
- func Last[S ~[]T, T any](fun func(x T) bool, arr S) T
- func Lead[T any](arr []T, n int, def T) []T
- func Map[S ~[]T, T any, U any](fun func(x T) U, arr S) []U
- func Map2[S ~[]T, T any, U ~[]V, V any, R any](f func(x T, y V) R, s S, v U) []R
- func Max[S ~[]T, T gotools.Ordered](arr S) T
- func Mean[S ~[]T, T gotools.Number](arr S) T
- func Merge[S ~[]T, T any](f func(x T, y T) bool, arr ...S) []T
- func Min[S ~[]T, T gotools.Ordered](arr S) T
- func Order[D ~[]U, S ~[]T, T any, U gotools.Ordered](arr S, order D, descending bool) (S, D)
- func OrderFun[D ~[]U, S ~[]T, T any, U any](f func(x, y U) bool, arr S, order D) (S, D)
- func OrderFun2[D ~[]U, S ~[]T, T any, U any](f func(x, y U) bool, arr S, order D)
- func OrderL[D ~[]U, S ~[]T, T any, U gotools.Ordered](arr S, order D)
- func OrderR[D ~[]U, S ~[]T, T any, U gotools.Ordered](arr S, order D)
- func Product[S ~[]T, T gotools.Number](arr S) float64
- func RandomSample[S ~[]T, T any](input S, samples int, replace bool) []T
- func Reduce[S ~[]T, T, U any](fun func(x U, y T) U, init U, arr S) U
- func ReduceR[S ~[]T, T, U any](fun func(x U, y T) U, init U, arr S) U
- func Rep[S ~[]T, T any](x S, n int, sort bool) []T
- func Repeat[T any](x T, n int) []T
- func Repeated[S ~[]T, T any](x S, n int) []T
- func Reverse[S ~[]T, T any](arr S) []T
- func ReverseFill[S ~[]T, T any](fun func(x T) bool, arr S) []T
- func ReverseSplit[S ~[]T, T any](fun func(x T) bool, arr S) [][]T
- func Rotate[S ~[]T, T any](arr S, n int) []T
- func Scan[S ~[]T, T, U any](fun func(x U, y T) U, init U, arr S) []U
- func ScanR[S ~[]T, T, U any](fun func(x U, y T) U, init U, arr S) []U
- func Seq(start, end, step int) []int
- func Shif[S ~[]T, T any](arr S, n int) []T
- func Sort[S ~[]T, T gotools.Ordered](arr S, descending bool) []T
- func SortFun[S ~[]T, T any](f func(x T, y T) bool, arr S) []T
- func SortFun2[S ~[]T, T any](f func(x T, y T) bool, arr S)
- func SortL[S ~[]T, T gotools.Ordered](arr S)
- func SortR[S ~[]T, T gotools.Ordered](arr S)
- func Split[S ~[]T, T any](fun func(x T) bool, arr S) [][]T
- func SubS[S ~[]T, T gotools.Comparable](a, b S) []T
- func Subtract[S ~[]T, T any, U gotools.Comparable](f func(x T) U, a, b S) []T
- func Sum[S ~[]T, T gotools.Number](arr S) T
- func ToAny[S ~[]T, T any](arr S) []any
- func ToGeneric[T any](arr []any) []T
- func ToMap[K gotools.Comparable](arr []K) map[K]struct{}
- func ToMap2[K ~[]T, V ~[]S, T gotools.Comparable, S any](key K, value V) map[T]S
- func ToZero[S ~[]T, T gotools.Comparable](arr S) map[T]int
- func Toint(arr []bool) []int
- func Transform[S ~[]F, D ~[]T, F gotools.Comparable, T any](x S, array_from S, array_to D, default_value T) []T
- func Union[S ~[]T, T any, U gotools.Comparable](f func(x T) U, a, b S) []T
- func UnionS[S ~[]T, T gotools.Comparable](a, b S) []T
- func Unique[S ~[]T, T gotools.Ordered](arr S) []T
- func UniqueCount[S ~[]T, T gotools.Ordered](arr S) int
- func Walk[S ~[]T, T any](fun func(T), input S)
- func Which[T any](fun func(x ...T) bool, arr ...[]T) []int
- type Cycle
Constants ¶
This section is empty.
Variables ¶
var ( LETTERS = []string{ "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", } Letters = []string{ "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", } )
Functions ¶
func All ¶
All 检查切片中所有元素是否都满足提供的条件函数。
参数:
- fun: 一个函数，接受 T 类型的变长参数并返回布尔值，用于测试一组元素是否满足条件。
- arr: T 类型的切片
返回值:
- 如果所有元素均使得 `fun` 返回 true，则返回 true；只要有一个不满足则返回 false。 如果输入切片数组为空，则直接返回 false
func Any ¶
Any 检查切片中是否有任一元素满足提供的条件函数。
参数:
- fun: 一个函数，接受 T 类型的变长参数并返回布尔值，用于测试一组元素是否满足条件。
- arr: T 类型的切片
返回值:
- 如果至少有一个元素使得 `fun` 返回 true，则返回 true；否则返回 false。 如果输入切片数组为空，则直接返回 false。
func ArrSequenceCount ¶
func ArrSequenceCount[A ~[]T, T gotools.Comparable](arr1 A, arr2 A) int
SequenceCount 计算一个数组中特定序列出现的次数。
参数:
- arr1[A]: 被搜索的数组，A 类型为切片，元素类型为 T。
- arr2[A]: 需要计数的序列，类型与 arr1 相同。
返回值:
- int: arr1 中 arr2 序列出现的次数。
注意:
- A 和 T 使用类型参数，要求 T 类型的元素可比较。
func Cartesian ¶
func Cartesian[S ~[]T, T any](arr ...S) [][]T
Cartesian函数生成多个切片的笛卡尔积。 参数:
- arr: 一个切片，表示要进行笛卡尔积的切片。
返回:
- [][]T: 一个二维切片，表示笛卡尔积后的切片。
函数返回类型为`[][]T`的切片，表示输入切片的笛卡尔积。 例如:Cartesian([][]int{{1, 2}, {3, 4}}...) = [][]int{{1, 3}, {1, 4}, {2, 3}, {2, 4}}
func Choose ¶
Choose 根据提供的索引数组重新排列给定的泛型数组元素。 参数:
- arr: 需要被重新排序的原数组，类型为泛型数组 S。
- index: 一个整数索引数组，指示原数组元素在结果数组中的新位置。
返回值:
- 返回一个与原数组相同类型的数组 S，其元素按照 index 指定的新顺序排列。
注意: 索引数组中的 - 1 值会被跳过，不会影响结果数组的构建。
func Chunk ¶
Chunk 切片分片 参数:
- size: 一个整数，表示每个切片的大小。
- arr: 一个切片，表示要进行分片的切片。
返回:
- [][]T: 一个二维切片，表示分片后的切片。
例如：ArrayChunk(2, [1, 2, 3, 4, 5, 6, 7, 8, 9])) // => [[1, 2], [3, 4], [5, 6], [7, 8], [9]]
func Compact ¶
func Compact[S ~[]T, T gotools.Comparable](arr S) []T
Compact 移除给定切片 S 中连续重复的元素，其中 S 是泛型类型 T 的切片，且 T 必须实现了 gotools.Ordered 接口。
参数:
- arr: 类型为 S 的切片，可能包含连续重复的元素。
返回值:
- 一个新的切片，其中连续重复的元素已被移除。
此函数遍历输入切片，仅将与前一个元素不同的元素添加到结果切片中， 从而实现连续重复元素的紧凑化处理。如果输入切片为空，则返回同类型的空切片。
func CompactAny ¶
CompactAny 移除给定切片 S 中连续重复的元素，其中 S 是泛型类型 T 的切片 ，且 T 为任意类型。
参数:
- arr: 类型为 S 的切片，可能包含连续重复的元素。
- fun: 用于比较两个元素是否相等的函数，类型为 func(x, y T) bool，其中 T 为任意类型。 相等则视为连续重复元素，不会追加到结果中
返回值:
- 一个新的切片，其中连续重复的元素已被移除。
此函数遍历输入切片，仅将与前一个元素不同的元素添加到结果切片中， 从而实现连续重复元素的紧凑化处理。如果输入切片为空，则返回同类型的空切片。
func Copy ¶
func Copy[T any](arr []T) []T
ArrayCopy 创建给定切片的一个副本。 它返回一个新的切片，其中包含与输入切片相同的元素。 参数:
- arr - 要复制的切片。
返回:
- 一个新的切片，它是输入切片的副本。
func CopyWithNum ¶
ArrayCopyWithNum 复制给定切片并创建一个新的切片，新切片的长度为 num。 如果 num 大于原切片长度，则重复原切片中的元素以填充新切片。 参数:
- arr - 要复制的切片。
- num - 新切片的长度。
返回:
- 一个新的切片，其长度为 num，且元素为 arr 的重复。
func CountIf ¶
CountIf 计算满足特定条件的元素数量 条件由提供的函数 `fun` 定义，该函数接受与输入切片数量相等的参数并返回一个布尔值。
参数:
- fun: 一个 variadic 函数，接受与输入切片数量相同的 T 类型参数，并返回一个布尔值。 当给定的元素满足某种条件时，应返回 `true`。
- arr: 参数为一个 S 类型的切片（元素类型为 T）
返回值:
- 返回一个整数，表示在所有切片中满足 `fun` 条件的元素的数量。
注意:
- 如果提供的切片为空，则函数返回 0。
func Difference ¶
Difference 计算类型为 S（元素类型为 T）的切片中相邻元素的差值，并返回一个新的切片。 要求 T 类型实现 gotools.Number 接口，支持减法运算。
参数:
- arr: 输入的切片 S，元素为可以进行减法运算的数值类型，且长度至少为 1。
返回值:
- 返回一个新的 S 类型切片，其中第 i 项是原切片中第 i 项与第 i - 1 项的差值。 第一项默认为原切片的第一项，之后的每一项都是后一项减去前一项的结果。
示例:
输入: []int{5, 2, 9, 1}
输出: []int{5, - 3, 7, - 8}
func Distinct ¶
func Distinct[S ~[]T, T gotools.Comparable](arr S) []T
Distinct 去重数组元素 参数:
- arr: 一个切片，表示要进行去重的切片。
返回:
- []T: 一个新的切片，表示去重后的切片。
func DistinctCount ¶
func DistinctCount[S ~[]T, T gotools.Comparable](arr S) int
DistinctCount 去重数组元素的数量 参数:
- arr: 一个切片，表示要进行去重的切片。
返回:
- int: 一个整数，表示去重后的切片的数量。
func EnumerateDense ¶
func EnumerateDense[S ~[]T, T gotools.Comparable](arr S) []int
EnumerateDense 为输入的数组中每个元素生成一个索引列表，其中的值对应该元素在数组中首次出现的位置。 参数:
- arr: 类型为 S 的数组，S 必须是类似切片的类型且其元素类型 T 可比较。
返回值:
- 一个整数切片，长度与输入数组相同，其中的值表示对应元素在数组中首次出现的索引。
func Fill ¶
Fill 根据提供的条件函数填充新切片。对于每个索引位置，如果条件函数应用于对应位置的元素返回 false， 则新切片中的该位置元素取自前一个索引位置的首个切片的元素；否则，取自当前索引位置的原始切片的元素。
参数:
- fun: 一个函数，接受 T 类型的变长参数并返回布尔值，决定是否采用当前索引的值。
- arr: T 类型的切片
返回值:
- 一个新的切片 S，其中元素根据 `fun` 的判断结果从输入切片的相应位置或前一位置选取。 若输入为空，则返回空 T 类型切片。 第一个元素不判断
func Filter ¶
Filter 根据提供的函数过滤多个同结构切片（类型为 T 的切片）的元素。 它将切片的对应元素作为参数传递给函数 `fun`，并仅保留 `fun` 返回真值时的切片中的元素。
参数:
- fun: 一个函数，接受 T 类型的变长参数，返回布尔值，指示是否保留当前元素。
- arr: 每个元素为 T 类型的切片
返回值:
- 一个新的切片 S，包含根据 `fun` 筛选后的元素。若输入为空或首切片为空，则返回空切片 S。
func FilterIndex ¶
FilterIndex 根据提供的函数过滤切片（类型为 T 的切片）的元素索引。 它将切片的对应元素作为参数传递给函数 `fun`，并仅保留 `fun` 返回真值时的位置索引。
参数:
- fun: 一个函数，接受 T 类型的变长参数，返回布尔值，指示是否保留当前元素。
- arr: 每个元素为 T 类型的切片
返回值:
- 一个新的切片 S，包含根据 `fun` 筛选后的元素的索引。若输入为空或首切片为空，则返回空切片 []int。
func FindFirst ¶
FindFirst 查找切片中第一个使条件函数 `fun` 返回 true 的元素所在的索引位置。
参数:
- fun: 一个函数，接受 T 类型的变长参数并返回布尔值，用于测试一组元素是否满足条件。
- arr: T 类型的切片
返回值:
- 第一个满足条件的元素在原数组中的起始索引位置。 如果没有找到满足条件的组合，则返回 - 1。 如果输入切片数组为空，则直接返回 - 1。
func FindLast ¶
FindLast 查找切片中最后一个使条件函数 `fun` 返回 true 的元素所在的索引位置。
参数:
- fun: 一个函数，接受 T 类型的变长参数并返回布尔值，用于测试一组元素是否满足条件。
- arr: T 类型的切片
返回值:
- 最后一个满足条件的元素在原数组中的起始索引位置。 如果没有找到满足条件的组合，则返回 - 1。 如果输入切片数组为空，则直接返回 - 1。
func FindMax ¶
FindMax 查找类型为 S（元素类型为 T）的切片中最大元素的索引位置。
参数:
- arr: 类型为 S 的切片，元素必须是可比较的（实现 gotools.Ordered 接口）。
返回值:
- 返回切片中最大元素的索引。如果切片为空，则行为未定义（可能返回 0，具体取决于编译器和运行环境）。
注意: 此函数假定切片非空，并且切片中的元素能够相互比较以确定大小关系。
func FindMin ¶
FindMin 查找类型为 S（元素类型为 T）的切片中最小元素的索引位置。
参数:
- arr: 类型为 S 的切片，元素必须是可比较的（实现 gotools.Ordered 接口）。
返回值:
- 返回切片中最小元素的索引。如果切片为空，则行为未定义（可能返回 0，具体取决于编译器和运行环境）。
func First ¶
First 查找切片中第一个使条件函数 `fun` 返回 true 的元素，并返回该组合的第一个元素。
参数:
- fun: 一个函数，接受 T 类型的变长参数并返回布尔值，用于测试一组元素是否满足条件。
- arr: T 类型的切片
返回值:
- 第一个满足条件的元素中的第一个元素。 如果没有找到满足条件的组合，则返回 T 类型的零值。 如果输入切片数组为空，则直接返回 T 类型的零值。
func FlatMap ¶
FlatMap 对切片（S，类型为 T 的切片）应用一个函数 ： 并收集返回值形成一个新的 U 类型切片序列。
参数:
- fun: 一个函数，接受 T 类型的变长参数，并返回 U 类型的结果。
- arr: 元素为类型为 S 的切片
返回值:
- 一个 U 类型的切片，其元素为对输入切片每相同索引位置的元素应用 `fun` 函数后的结果。 若输入为空，则返回空切片。
func From ¶
func From[T any](input ...T) []T
From 函数接受任意类型的输入参数，并将它们转换为切片。
参数:
- input: 可变长度参数，表示要转换为切片的输入值
返回:
- 一个包含输入值的切片
func FromConvert ¶
func FromConvert[T, U any](fun func(T) U, input ...T) []U
FromConvert 函数接受一个函数和任意数量的输入参数，根据函数的返回值决定是否将输入值添加到切片中。
参数:
- fun: 一个函数，接受 T 类型的变长参数并返回 U 类型的结果，用于添加到切片中。
- input: 可变长度参数，表示要转换为切片的输入值
返回:
- 一个包含输入值的切片
func FromIf ¶
FromIf 函数接受一个函数和任意数量的输入参数，根据函数的返回值决定是否将输入值添加到切片中。
参数:
- fun: 一个函数，接受 T 类型的变长参数并返回 bool，用于判断是否添加到切片中。
- input: 可变长度参数，表示要转换为切片的输入值
返回:
- 一个包含输入值的切片
func Has ¶
func Has[S ~[]T, T gotools.Comparable](arr S, elem T) bool
Has 检查类型为 S（元素类型为 T）的切片中是否包含指定的元素。 要求 T 类型实现 gotools.Comparable 接口，以便进行相等性比较。
参数:
- arr: 要检查的切片 S。
- elem: 要搜索的元素 T。
返回值:
- 如果切片 `arr` 包含元素 `elem`，则返回 `true`；否则返回 `false`。
func HasAll ¶
func HasAll[S ~[]T, T gotools.Comparable](arr S, elems ...T) bool
HasAll 检查类型为 S（元素类型为 T）的切片是否包含指定的所有元素。 要求 T 类型实现 gotools.Comparable 接口，允许元素之间的相等性比较。
参数:
- arr: 要检查的切片 S。
- elems: 可变数量参数，表示要查找的所有元素 T 组成的集合。
返回值:
- 如果切片 `arr` 包含 `elems` 中的所有元素，则返回 `true`；否则返回 `false`。
func HasAny ¶
func HasAny[S ~[]T, T gotools.Comparable](arr S, elems ...T) bool
HasAny 检查类型为 S（元素类型为 T）的切片是否包含至少一个指定的元素。 要求 T 类型实现 gotools.Comparable 接口，允许元素之间的相等性比较。
参数:
- arr: 要检查的切片 S。
- elems: 可变数量参数，表示要查找的一个或多个元素 T。
返回值:
- 如果切片 `arr` 中包含 `elems` 中的至少一个元素，则返回 `true`；否则返回 `false`。
func HasDupMaxCount ¶
func HasDupMaxCount[S ~[]T, T gotools.Comparable](source, match S) int
HasDupMaxCount 计算源切片中与匹配切片元素相等的元素个数， 并在遇到第一个重复元素时停止计算。 这个函数使用泛型，S 表示切片的类型，而 T 表示切片元素的类型， 其中 T 必须是可比较的。
参数：
- source: 待检查的源切片。
- match: 用于匹配的参考切片。
返回值：
- 返回源切片中与 match 中元素相等的元素个数。
- 如果在计数过程中发现源切片中有重复元素，则提前终止并返回当前计数值。
func HasIncreaseMaxCount ¶
func HasIncreaseMaxCount[S ~[]T, T gotools.Comparable](source, match S) int
HasIncreaseMaxCount 计算源切片中与匹配切片元素相等的连续元素个数。 此函数使用泛型，其中 S 表示切片的类型，T 表示切片元素的类型， 要求 T 必须是可比较的类型。
参数：
- source: 待检查的源切片。
- match: 用于匹配的参考切片。
返回值：
- 返回源切片中与 match 中元素相等的连续元素个数。
- 当 match 中的所有元素都已在 source 中找到匹配或 source 中不再有匹配元素时，停止计数并返回结果。
func HasOrderMaxCount ¶
func HasOrderMaxCount[S ~[]T, T gotools.Comparable](source, match S, exist map[T]struct{}) int
HasOrderMaxCount 检查在给定的映射存在性验证下，切片 source 中有多少个元素可以按照切片 match 的顺序出现。 在source中出现了match中未出现的元素，停止计算返回 这个函数返回的是 source 中与 match 顺序一致的最长连续子序列的长度。
参数:
- a: 类型为 S 的切片，S 是一个泛型切片，其元素类型为 T。
- b: 类型同样为 S 的切片，作为参考顺序。
- exist: 一个映射，键为 T 类型，用于快速判断元素是否存在于某个集合中。
返回值:
- 返回一个整数，表示 source 中与 match 顺序一致的最长连续子序列的长度。
func HasSequence ¶
func HasSequence[A ~[]T, T gotools.Comparable](arr1 A, arr2 A) (bool, int)
ArrayHasSequence 检查数组arr1中是否包含数组arr2作为连续子序列。
参数：
- arr1 (A): 可能包含子序列的数组，类型A为切片的约束类型。
- arr2 (A): 需要查找的连续子序列，类型与arr1相同。
返回值：
- bool: 如果arr2是arr1中的一个连续子序列，则返回true，否则返回false。
此函数利用类型约束[A ~[]T, T gotools.Comparable]确保传入的参数为切片类型且元素可比较。 通过遍历arr1并逐一比对arr2的所有元素来判断子序列是否存在。
注意:
- 如果arr1或arr2为空，函数返回false,0。
func InsertAt ¶
InsertAt 在指定多个位置插入数据，当前位置的数据顺延到下一个位置 参数:
- data: 一个切片，表示要插入的数据
- pos: 一个切片，表示要插入的位置
返回:
- func(default_x T) []T: 一个函数，用于插入默认值
例如:
InsertAt([]int{1, 2, 3, 4}, 1, 3, 5)(0) // => [1 0 2 0 3 0 4]
InsertAt([]int{1, 2, 3, 4}, 1, 3, 5，7)(0) // => [1 0 2 0 3 0 4]
func InterS ¶
func InterS[S ~[]T, T gotools.Comparable](a, b S) []T
InterS 计算两个切片（类型为 []T，元素类型 T 可比较）的交集。
参数:
- a: 一个切片。
- b: 一个切片。
返回值:
- 一个新的 []T 类型的切片，包含所有输入切片中共有的元素，且元素顺序与它们在第一个切片中出现的顺序一致。 如果没有交集或输入为空，则返回一个空切片。
func Intersect ¶
func Intersect[S ~[]T, T any, U gotools.Comparable](f func(x T) U, a, b S) []T
Intersect 计算两个切片（类型为 []T，元素类型 T 任意类型）的交集。
参数:
- f: 一个函数，用于将元素转换为可比较的类型。
- a: 一个切片。
- b: 一个切片。
返回值:
- 一个新的 []T 类型的切片，包含所有输入切片中共有的元素，且元素顺序与它们在第一个切片中出现的顺序一致。 如果没有交集或输入为空，则返回一个空切片。
func Lag ¶
Lag 生成一个新的切片，该切片由输入切片 `arr` 第n个元素前面的元素组成。缺少部分使用 `def` 填充。
参数:
- arr: 类型为 `[]T` 的输入切片，包含类型为 `T` 的元素。
- n: 指定 `arr` 中的第 `n` 个元素前面的元素组成新的切片。
- def: 用于填充缺失的元素。
返回:
- 一个类型为 `[]T` 的新切片，包含 `arr` 的前 `n` 个元素。
func Last ¶
Last 查找切片中最后一个使条件函数 `fun` 返回 true 的元素，并返回该组合的第一个元素。
参数:
- fun: 一个函数，接受 T 类型的变长参数并返回布尔值，用于测试一组元素是否满足条件。
- arr: T 类型的切片
返回值:
- 最后一个满足条件的元素中的第一个元素。 如果没有找到满足条件的组合，则返回 T 类型的零值。 如果输入切片数组为空，则直接返回 T 类型的零值。
func Lead ¶
Lead 生成一个新的切片，该切片由输入切片 `arr` 第n个元素后面的元素组成。缺少部分使用 `def` 填充。
参数:
- arr: 类型为 `[]T` 的输入切片，包含类型为 `T` 的元素。
- n: 指定 `arr` 中的第 `n` 个元素后面的元素组成新的切片。
- def: 用于填充缺失的元素。
返回:
- 一个类型为 `[]T` 的新切片，包含输入切片 `arr` 中第 `n` 个元素后面的元素。
func Map ¶
Map 对切片（S，类型为 T 的切片）应用一个函数 ， 并收集返回值形成一个新的 U 类型切片序列。
参数:
- fun: 一个函数，接受 T 类型的变长参数，并返回 U 类型的结果。
- arr: 每个元素为类型为 S 的切片
返回值:
- 一个 U 类型的切片，其元素为对输入切片每相同索引位置的元素应用 `fun` 函数后的结果。 若输入为空 ，则返回空切片。
func Map2 ¶
Map2 用于将一个函数应用于两个切片的每个元素。 参数:
f - 一个函数，接受两个类型为 T 和 V 的参数，返回一个类型为 R 的值。 s - 一个包含 T 类型元素的切片。 v - 一个包含 V 类型元素的切片。
返回:
一个包含 R 类型元素的切片。
func Max ¶
Max 返回类型为 S（元素类型为 T）的切片中的最大元素。
参数:
- arr: 类型为 S 的切片，元素需要可比较（实现 gotools.Ordered 接口）。
返回值:
- 切片中的最大元素。 如果切片为空，则返回 T 类型的默认值（这可能是未定义的行为，具体取决于 T 的类型）。
func Mean ¶
Mean 计算类型为 S（元素类型为 T）的切片中所有元素的平均值。
参数:
- arr: 类型为 S 的切片，元素应为可以相加和除法运算的数字类型（实现 gotools.Number 接口）。
返回值:
- 切片中所有元素的平均值。
func Merge ¶
Merge 通过比较函数对多个切片进行合并，返回一个新的切片, 要求传入切片必须排序 参数:
- f: 一个函数，接受两个类型为 T 的值，返回一个布尔值 当 `fun(x, y)` 返回 `true`，则在排序时 `x` 应位于 `y` 之前。
- arr: 一个切片，表示要进行合并的切片。
返回:
- []T: 一个新的切片，表示合并后的切片。
func Min ¶
Min 返回类型为 S（元素类型为 T）的切片中的最小元素。
参数:
- arr: 类型为 S 的切片，元素需要可比较（实现 gotools.Ordered 接口）。
返回值:
- 切片中的最小元素。 如果切片为空，则返回 T 类型的默认值（这可能是未定义的行为，具体取决于 T 的类型）。
func Order ¶
Order 对切片进行排序，order切片类型必须实现 Ordered 接口
参数:
- arr: 一个切片，表示要进行排序的切片。
- order: 一个切片，表示排序后的顺序。
- descending: 一个布尔值，表示是否降序排序。
返回:
- 一个新的切片，表示排序后的结果。
- 一个新的切片，表示排序后的顺序。
func OrderFun ¶
OrderFun 通过比较函数对切片进行排序
参数:
- f: 一个函数，接受两个 T 类型的变长参数并返回布尔值，决定是否交换两个元素的位置。true 表示交换，false 表示不交换。
- arr: 一个切片，表示要进行排序的切片。
- order: 一个切片，表示排序后的顺序。
返回:
- 一个新的切片，表示排序后的结果。
func OrderFun2 ¶
OrderFunLocal 通过比较函数对切片进行排序，修改原切片
参数:
- f: 一个函数，接受两个 T 类型的变长参数并返回布尔值，决定是否交换两个元素的位置。true 表示交换，false 表示不交换。
- arr: 一个切片，表示要进行排序的切片。
- order: 一个切片，表示排序后的顺序。
无返回值
func OrderL ¶
OrderL 对切片进行升序排序，order切片类型必须实现 Ordered 接口
参数:
- arr: 一个切片，表示要进行排序的切片。
- order: 一个切片，表示排序后的顺序。
无返回值
func OrderR ¶
OrderR 对切片进行降序排序，order切片类型必须实现 Ordered 接口
参数:
- arr: 一个切片，表示要进行排序的切片。
- order: 一个切片，表示排序后的顺序。
无返回值
func Product ¶
Product 计算类型为 S（元素为 gotools.Number 类型）的切片的所有元素的乘积，并返回结果为 float64 类型。
参数:
- arr: 类型为 S 的切片，其元素需要实现 gotools.Number 接口（通常包括 int、float32、float64 等数字类型）。
返回值:
- 所有切片元素相乘的结果，转换为 float64 类型返回。 如果切片为空，则返回 1.0，遵循数学中乘积的空集定义。
func RandomSample ¶
RandomSample 从输入切片 S（类型为 T）中随机抽取指定数量的元素，返回一个新的切片 S。
参数:
- input: 类型为 S 的切片，从中进行随机抽样。
- samples: 需要抽取的样本数量，必须小于输入切片的长度。
返回值:
- 一个新的切片 S，包含从输入切片中随机选取的 `samples` 个元素。 如果 `samples` 大于等于输入切片的长度，则直接返回原切片。
此函数使用当前时间作为随机数生成器的种子，确保每次调用都能得到不同的随机结果。
func Reduce ¶
func Reduce[S ~[]T, T, U any](fun func(x U, y T) U, init U, arr S) U
Reduce 对切片中的元素从左到右应用一个累积函数，并返回该函数处理后的结果。 此函数泛型，适用于任何类型的切片和累积函数，只要累积函数的输入输出类型与切片元素类型兼容。
参数:
arr 需要被归约处理的切片。类型为 S，其中 S 是 T 类型元素的切片。
fun 累积函数，接收两个参数：累积结果（类型为 U）和切片中的当前元素（类型为 T），
init 初始累积值，类型为 U。
并返回一个新的累积结果（同样为 U 类型）。此函数定义了如何将单个元素累积到整体结果中。
返回值:
应用累积函数后得到的最终结果。类型为 U，累积过程的起始值为 U 的零值。
如果切片为空，则直接返回 U 的零值。
注意事项:
- 累积函数 `fun` 应确保对于所有可能的输入都是正确的，并且应当处理好任何潜在的边界条件或错误情况。
- 若 `result` 是引用类型（如切片、map），其初始零值可能影响结果的预期。确保理解并适当处理此类情况。
func ReduceR ¶
func ReduceR[S ~[]T, T, U any](fun func(x U, y T) U, init U, arr S) U
ReduceR 对切片中的元素从右到左应用一个累积函数，并返回该函数处理后的结果。 此函数泛型，适用于任何类型的切片和累积函数，只要累积函数的输入输出类型与切片元素类型兼容。
func Rep ¶
Rep 生成一个新的切片，该切片由输入切片 `x` 的元素重复 `n` 次组成。
参数:
- x: 类型为 `S` 的输入切片，包含类型为 `T` 的元素。
- n: 每个 `x` 中的元素应重复的次数。
- sort: 一个布尔标志，指示生成的切片是否应进行排序。
返回:
- 一个类型为 `[]T` 的新切片，包含重复的 `x` 元素。
func Repeat ¶
Repeat 创建一个包含相同元素的切片。 它接受一个类型为 T 的元素和一个整数 n，返回一个长度为 n 的切片，其中所有元素都与 x 相同。 这个函数的目的是为了方便地初始化一个切片，当切片的所有元素都相同时，可以避免重复的初始化代码。 参数:
- x: 类型为 T 的元素，切片中的每个元素都将复制这个值。
- n: 切片的长度，指定切片将包含多少个元素。
返回值:
- 一个类型为 []T 的切片，长度为 n，其中所有元素都等于 x。
func Repeated ¶
Repeated 创建一个包含相同重复切片的切片，该切片的长度等于n*len(x)。
参数:
- x: 类型为 S 的切片，将复制到结果切片中。
- n: 指定结果切片的长度，每个元素将复制 `x` `n` 次。
返回值:
- 一个类型为 []T 的切片，长度为 n*len(x)，其中每个元素都是 `x` 的副本。
func Reverse ¶
func Reverse[S ~[]T, T any](arr S) []T
Reverse 反转给定的切片 S，其中 S 是泛型类型 T 的切片。
参数:
- arr: 类型为 S 的切片，需要被反转。
返回值:
- 反转后的切片 S，与输入切片类型相同。
当输入切片为空时，会直接返回同类型的空切片。
func ReverseFill ¶
ReverseFill 根据提供的条件函数反向填充新切片。它从最后一个元素开始向前遍历， 对于每个索引位置，使用条件函数 `fun` 应用于对应位置的元素，决定该位置的值。 如果 `fun` 返回 false，则新切片中的该位置元素取自后一个索引的值（即更靠近末尾的值）； 如果 `fun` 返回 true，则取自当前索引的值。
参数:
- fun: 一个函数，接受 T 类型的变长参数并返回布尔值，决定是否采用当前或下一个索引的值。
- arr: T 类型的切片
返回值:
- 一个新的切片 S，其中元素根据 `fun` 的判断结果从前一个或当前索引的值中选取。 若输入为空，则返回空 T 类型切片。 最后一个元素不判断
func ReverseSplit ¶
ReverseSplit 根据提供的条件函数反向地将输入切片 S（类型为 T）分割成多个子切片，并返回这些子切片组成的切片。 与 `ArraySplit` 不同，此函数在条件满足的位置进行切割，并且包含切割点的元素在下一个子切片中。
参数:
- fun: 一个函数，接受 T 类型的变长参数并返回布尔值，决定是否在当前位置进行切分。
- arr: T 类型的切片
返回值:
- 一个由 S 类型子切片组成的切片，每个子切片代表原切片中满足分割条件的相邻部分。 区别在于，当条件满足时，该元素会包含在后续的子切片中，而非当前子切片的结尾。 若输入为空或首切片为空，则返回空 S 类型切片的切片
注意:
- 数组将在元素的右侧进行拆分。
func Rotate ¶
Rotate 对输入的切片 S（类型为 T）进行循环旋转操作。
参数:
- arr: 类型为 S 的切片，需要进行旋转操作。
- n: 旋转步数，正数表示向右旋转，负数表示向左旋转。
返回值:
- 新的 T 类型切片，为旋转操作后得到的结果。 如果输入切片为空，则直接返回原切片。
func Scan ¶
func Scan[S ~[]T, T, U any](fun func(x U, y T) U, init U, arr S) []U
Scan 对切片中的元素从左到右应用一个扫描函数，并返回该函数处理后的结果。 此函数泛型，适用于任何类型的切片和扫描函数，只要扫描函数的输入输出类型与切片元素类型兼容。
参数:
arr 需要被扫描处理的切片。类型为 S，其中 S 是 T 类型元素的切片。
fun 扫描函数，接收两个参数：扫描结果（类型为 U）和切片中的当前元素（类型为 T）,
init 初始扫描值，类型为 U。
并返回一个新的扫描结果（同样为 U 类型）
返回值:
应用扫描函数后得到的最终结果。类型为 U，扫描过程的起始值为 U 的零值。
如果切片为空，则直接返回 U 的零值。
注意事项:
- 扫描函数 `fun` 应确保对于所有可能的输入都是正确的，并且应当处理好任何潜在的边界条件或错误情况。
- 若 `result` 是引用类型（如切片、map），其初始零值可能影响结果的预期。确保理解并适当处理此类情况。
func ScanR ¶
func ScanR[S ~[]T, T, U any](fun func(x U, y T) U, init U, arr S) []U
ScanR 对切片中的元素从右到左应用一个扫描函数，并返回该函数处理后的结果。
func Seq ¶
Seq 创建一个整数数组，该数组基于起始值、结束值和步长。 它返回一个包含从start到end（但不包括end）的整数的切片，每个相邻元素之间的差值为step。 如果step为0，表示没有有效的步长，返回一个空切片。 如果step为正数且start大于end，或者step为负数且start小于end，也返回一个空切片，因为在这种情况下无法生成有效的序列。 参数:
- start - 序列的起始整数值。
- end - 序列的结束整数值，不包括在结果中。
- step - 序列中相邻元素之间的步长。
返回值:
- 一个整数切片，包含从start到end（但不包括end）的整数，每个相邻元素之间的差值为step
func Shif ¶
Shif 对输入的切片 S（类型为 T）进行循环移位操作。
参数:
- arr: 类型为 S 的切片，将被移位。
- n: 移位步数，正数表示向右移位，负数表示向左移位。
返回值:
- 新的 T 类型切片，为移位操作后得到的结果。 如果输入切片为空，则直接返回原切片。
func Sort ¶
Sort 对切片进行排序, 切片类型必须实现 Ordered 接口
参数:
- arr: 一个切片，表示要进行排序的切片。
- descending: 一个布尔值，表示是否降序排序。
返回:
- 一个新的切片，表示排序后的结果。
func SortFun ¶
SortFun 通过比较函数对切片进行排序
参数:
- f: 一个函数，接受两个 T 类型的变长参数并返回布尔值，决定是否交换两个元素的位置。true 表示交换，false 表示不交换。
- arr: 一个切片，表示要进行排序的切片。
返回:
- 一个新的切片，表示排序后的结果。
func SortFun2 ¶
SortFun2 通过比较函数对切片进行排序，修改原切片
参数:
- f: 一个函数，接受两个 T 类型的变长参数并返回布尔值，决定是否交换两个元素的位置。true 表示交换，false 表示不交换。
- arr: 一个切片，表示要进行排序的切片。
无返回值
func Split ¶
Split 根据提供的条件函数将输入切片 S（类型为 T）分割成多个子切片，并返回这些子切片组成的切片。 条件函数 `fun` 应用于输入切片的每个元素，当 `fun` 返回 true 时，会在该位置切割切片。
参数:
- fun: 一个函数，接受 T 类型的变长参数并返回布尔值，决定是否在当前位置进行切分。
- arr: T 类型的切片
返回值:
- 一个由 S 类型子切片组成的切片，每个子切片代表原切片中满足分割条件相邻的部分。 若输入为空或首切片为空，则返回空 S 类型切片的切片。
注意:
- 数组将在元素的左侧进行拆分。
- 数组不会在第一个元素之前被分割。
func SubS ¶
func SubS[S ~[]T, T gotools.Comparable](a, b S) []T
SubS 计算两个切片（类型为 []T，元素类型 T 可比较）的差集。
参数:
- a: 一个切片。
- b: 一个切片。
返回值:
- 一个新的 []T 类型的切片，包含所有输入切片中不在第二个切片中出现的元素，且元素顺序与它们在第一个切片中出现的顺序一致。 如果没有差集或输入为空，则返回一个空切片。
func Subtract ¶
func Subtract[S ~[]T, T any, U gotools.Comparable](f func(x T) U, a, b S) []T
Subtract 计算两个切片（类型为 []T，元素类型 T 任何类型）的差集。
参数:
- f: 一个函数，用于将元素转换为可比较的类型。
- a: 一个切片。
- b: 一个切片。
返回值:
- 一个新的 []T 类型的切片，包含所有输入切片中不在第二个切片中出现的元素，且元素顺序与它们在第一个切片中出现的顺序一致。 如果没有差集或输入为空，则返回一个空切片。
func Sum ¶
Sum 计算类型为 S（元素类型为 T）的切片中所有元素的总和。
参数:
- arr: 类型为 S 的切片，元素应为可以相加的数字类型（实现 gotools.Number 接口）。
返回值:
- 切片中所有元素的和。 如果切片为空，则返回 T 类型的零值（对于数值类型通常是 0）。
func ToAny ¶
ToAny 将类型为 S（元素类型为 T）的切片转换为任意类型切片。 要求 T 类型实现 `any` 接口。
参数:
- arr: 要转换的切片 S。
返回值:
- 返回一个新的 []any 类型切片，包含输入的所有元素，保持原有的顺序。
func ToMap ¶
func ToMap[K gotools.Comparable](arr []K) map[K]struct{}
ToMap 将一个切片转换为一个映射(map)，其中切片中的每个元素作为键(key)， 值(value)是一个空结构体(struct{})。这个函数的目的是为了创建一个唯一的键集合， 由于结构体不占用存储空间，因此这种方式可以有效地表示一个集合。 参数:
- arr []K: 一个包含待转换为映射键的元素的切片。
返回值:
- map[K]struct{}: 一个映射，其中每个切片元素作为键，值是一个空结构体。
使用场景:
- 当需要从切片中快速查找某个元素是否存在时，可以将切片转换为映射，利用映射的O(1)查找复杂度。
- 该函数非常有用，因为它可以快速地创建一个唯一的键集合，从而节省内存空间。
func ToMap2 ¶
func ToMap2[K ~[]T, V ~[]S, T gotools.Comparable, S any](key K, value V) map[T]S
ToMap2 根据两个数组创建一个映射。 它接受两个参数：key和value，它们分别是K和V类型的数组。 函数返回一个map[T]S类型的映射，其中T和S是K和V数组元素的类型。 该函数的目的是通过索引匹配将key数组的元素作为映射的键，value数组的元素作为对应的值。 参数:
- key K: 用于映射的键的数组。
- value V: 与键对应的值的数组。
返回值:
- map[T]S: 一个映射，其中键来自key数组，值来自value数组。
注意:
- K和V的类型参数必须是数组类型，且K的元素类型必须是可比较的。
- 这个函数假设key和value数组的长度是相同的，以便进行索引匹配。
func ToZero ¶
func ToZero[S ~[]T, T gotools.Comparable](arr S) map[T]int
ToZero 将类型为 S（元素类型为 T）的切片转换为 map[T]int 类型。 要求 T 类型实现 `Comparable` 接口。
参数:
- arr: 要转换的切片 S。
返回值:
- 返回一个 map[T]int 类型的映射， 包含输入的所有元素，键为元素，值为 0。
func Transform ¶
func Transform[S ~[]F, D ~[]T, F gotools.Comparable, T any](x S, array_from S, array_to D, default_value T) []T
Transform 将切片 x 中的元素根据 array_from 和 array_to 的映射关系转换为新的类型 T， 并返回转换后的切片。如果 x 中的元素在映射中不存在，则使用 default_value 填充。 参数:
- x - 待转换的切片。
- array_from - 映射的键值切片。
- array_to - 映射的值切片。
- default_value - 当 x 中的元素在映射中不存在时使用的默认值。
返回:
一个新切片，其中元素为转换后的值。
func Union ¶
func Union[S ~[]T, T any, U gotools.Comparable](f func(x T) U, a, b S) []T
Union 计算两个切片（类型为 []T，元素类型 T 任意类型）的并集。
参数:
- f: 一个函数，用于将元素转换为可比较的类型。
- a: 一个切片。
- b: 一个切片。
返回值:
- 一个新的 []T 类型的切片，包含所有输入切片中的元素，且元素顺序与它们在第一个切片中出现的顺序一致。 如果没有交集或输入为空，则返回一个空切片。
func UnionS ¶
func UnionS[S ~[]T, T gotools.Comparable](a, b S) []T
UnionS 计算两个切片（类型为 []T，元素类型 T 可比较）的并集。
参数:
- a: 一个切片。
- b: 一个切片。
返回值:
- 一个新的 []T 类型的切片，包含所有输入切片中的元素，且元素顺序与它们在第一个切片中出现的顺序一致。
func Unique ¶
Unique 移除类型为 S（元素类型为 T）的切片中的重复元素，并返回一个新的无重复元素的切片。 要求 T 类型实现 gotools.Ordered 接口，以便进行比较操作。
参数:
- arr: 输入的切片 S，可能包含重复元素。 要求必须是排序后的切片
返回值:
- 返回一个新的 S 类型切片，其中重复的元素已被移除，剩余元素按升序排列。
func UniqueCount ¶
UniqueCount 用于计算类型为 S（元素类型为 T）的切片中的唯一元素的个数。 要求 T 类型实现 gotools.Ordered 接口，以便进行比较操作。
参数:
- arr: 输入的切片 S，可能包含重复元素。要求必须是排序后的切片
返回值:
- 返回唯一元素的个数。
func Walk ¶
func Walk[S ~[]T, T any](fun func(T), input S)
Walk 逐元素执行函数。
参数:
- fun: 用于逐元素执行的函数。
- input: 切片
返回:
func Which ¶
Which 函数根据提供的判断函数fun，遍历多个切片数组arr的对应位置元素，判断这些元素是否满足fun定义的条件， 并记录满足条件的位置（以1表示）和不满足条件的位置（以0表示）到结果切片中返回。
参数:
- fun: 一个通用型函数，接受任意数量的T类型参数并返回一个布尔值，用于判断一组元素是否满足特定条件。
- arr: 可变数量的切片数组，每个切片包含相同数量的T类型元素，这些切片将被并行遍历以应用fun函数。
返回值:
- 一个int类型的切片，表示在对应位置上元素是否满足fun条件的结果。满足条件的位置记为1，不满足则记为0。
注意:
所有输入的切片arr必须具有相同的长度。
使用了Go泛型[T any]，允许该函数接受任何类型的参数和切片。
Source Files