feat: 新增 utils/sher 包，包含了对 slice 及 hash 常用的操作函数。用于未来对 utils/slice 和 utils/hash 包进行替换
This commit is contained in:
kercylan98
parent
a7b0497d4f
commit
515cbc66eb
|
|
@ -0,0 +1,88 @@
|
|||
package sher
|
||||
|
||||
import (
|
||||
"slices"
|
||||
)
|
||||
|
||||
// CloneMatrix 克隆二维数组
|
||||
func CloneMatrix[S ~[][]V, V any](slice S) S {
|
||||
if slice == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
var result = make(S, len(slice))
|
||||
for i := 0; i < len(slice); i++ {
|
||||
result[i] = CloneSlice(slice[i])
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// CloneSlice 克隆切片，该函数是 slices.Clone 的快捷方式
|
||||
func CloneSlice[S ~[]V, V any](slice S) S {
|
||||
return slices.Clone(slice)
|
||||
}
|
||||
|
||||
// CloneMap 克隆 map
|
||||
func CloneMap[M ~map[K]V, K comparable, V any](m M) M {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
var result = make(M, len(m))
|
||||
for k, v := range m {
|
||||
result[k] = v
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// CloneSliceN 克隆切片为 n 个切片进行返回
|
||||
func CloneSliceN[S ~[]V, V any](slice S, n int) []S {
|
||||
if slice == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
var result = make([]S, n)
|
||||
for i := 0; i < n; i++ {
|
||||
result[i] = CloneSlice(slice)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// CloneMapN 克隆 map 为 n 个 map 进行返回
|
||||
func CloneMapN[M ~map[K]V, K comparable, V any](m M, n int) []M {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
var result = make([]M, n)
|
||||
for i := 0; i < n; i++ {
|
||||
result[i] = CloneMap(m)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// CloneSlices 克隆多个切片
|
||||
func CloneSlices[S ~[]V, V any](slices ...S) []S {
|
||||
if slices == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
var result = make([]S, len(slices))
|
||||
for i, slice := range slices {
|
||||
result[i] = CloneSlice(slice)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// CloneMaps 克隆多个 map
|
||||
func CloneMaps[M ~map[K]V, K comparable, V any](maps ...M) []M {
|
||||
if maps == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
var result = make([]M, len(maps))
|
||||
for i, m := range maps {
|
||||
result[i] = CloneMap(m)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
|
@ -0,0 +1,308 @@
|
|||
package sher
|
||||
|
||||
import "sort"
|
||||
|
||||
type ComparisonHandler[V any] func(source, target V) bool
|
||||
|
||||
// InSlice 判断切片中是否包含某个元素
|
||||
func InSlice[S ~[]V, V any](slice S, v V, handler ComparisonHandler[V]) bool {
|
||||
if slice == nil {
|
||||
return false
|
||||
}
|
||||
for _, value := range slice {
|
||||
if handler(v, value) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// InSliceByBinarySearch 判断切片中是否包含某个元素，使用二分搜索
|
||||
func InSliceByBinarySearch[S ~[]V, V any](slice S, v V, handler ComparisonHandler[V]) bool {
|
||||
return sort.Search(len(slice), func(i int) bool {
|
||||
return handler(v, slice[i])
|
||||
}) != len(slice)
|
||||
}
|
||||
|
||||
// AllInSlice 判断切片中是否包含所有元素
|
||||
func AllInSlice[S ~[]V, V any](slice S, values []V, handler ComparisonHandler[V]) bool {
|
||||
if slice == nil {
|
||||
return false
|
||||
}
|
||||
for _, value := range values {
|
||||
if !InSlice(slice, value, handler) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// AllInSliceByBinarySearch 判断切片中是否包含所有元素，使用二分搜索
|
||||
func AllInSliceByBinarySearch[S ~[]V, V any](slice S, values []V, handler ComparisonHandler[V]) bool {
|
||||
if slice == nil {
|
||||
return false
|
||||
}
|
||||
for _, value := range values {
|
||||
if !InSliceByBinarySearch(slice, value, handler) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// AnyInSlice 判断切片中是否包含任意一个元素
|
||||
func AnyInSlice[S ~[]V, V any](slice S, values []V, handler ComparisonHandler[V]) bool {
|
||||
if slice == nil {
|
||||
return false
|
||||
}
|
||||
for _, value := range values {
|
||||
if InSlice(slice, value, handler) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// AnyInSliceByBinarySearch 判断切片中是否包含任意一个元素，使用二分搜索
|
||||
func AnyInSliceByBinarySearch[S ~[]V, V any](slice S, values []V, handler ComparisonHandler[V]) bool {
|
||||
if slice == nil {
|
||||
return false
|
||||
}
|
||||
for _, value := range values {
|
||||
if InSliceByBinarySearch(slice, value, handler) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// InSlices 判断多个切片中是否包含某个元素
|
||||
func InSlices[S ~[]V, V any](slices []S, v V, handler ComparisonHandler[V]) bool {
|
||||
return InSlice(MergeSlices(slices...), v, handler)
|
||||
}
|
||||
|
||||
// InSlicesByBinarySearch 判断多个切片中是否包含某个元素，使用二分搜索
|
||||
func InSlicesByBinarySearch[S ~[]V, V any](slices []S, v V, handler ComparisonHandler[V]) bool {
|
||||
return InSliceByBinarySearch(MergeSlices(slices...), v, handler)
|
||||
}
|
||||
|
||||
// AllInSlices 判断多个切片中是否包含所有元素
|
||||
func AllInSlices[S ~[]V, V any](slices []S, values []V, handler ComparisonHandler[V]) bool {
|
||||
return AllInSlice(MergeSlices(slices...), values, handler)
|
||||
}
|
||||
|
||||
// AllInSlicesByBinarySearch 判断多个切片中是否包含所有元素，使用二分搜索
|
||||
func AllInSlicesByBinarySearch[S ~[]V, V any](slices []S, values []V, handler ComparisonHandler[V]) bool {
|
||||
return AllInSliceByBinarySearch(MergeSlices(slices...), values, handler)
|
||||
}
|
||||
|
||||
// AnyInSlices 判断多个切片中是否包含任意一个元素
|
||||
func AnyInSlices[S ~[]V, V any](slices []S, values []V, handler ComparisonHandler[V]) bool {
|
||||
return AnyInSlice(MergeSlices(slices...), values, handler)
|
||||
}
|
||||
|
||||
// AnyInSlicesByBinarySearch 判断多个切片中是否包含任意一个元素，使用二分搜索
|
||||
func AnyInSlicesByBinarySearch[S ~[]V, V any](slices []S, values []V, handler ComparisonHandler[V]) bool {
|
||||
return AnyInSliceByBinarySearch(MergeSlices(slices...), values, handler)
|
||||
}
|
||||
|
||||
// InAllSlices 判断元素是否在所有切片中都存在
|
||||
func InAllSlices[S ~[]V, V any](slices []S, v V, handler ComparisonHandler[V]) bool {
|
||||
if slices == nil {
|
||||
return false
|
||||
}
|
||||
for _, slice := range slices {
|
||||
if !InSlice(slice, v, handler) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// InAllSlicesByBinarySearch 判断元素是否在所有切片中都存在，使用二分搜索
|
||||
func InAllSlicesByBinarySearch[S ~[]V, V any](slices []S, v V, handler ComparisonHandler[V]) bool {
|
||||
if slices == nil {
|
||||
return false
|
||||
}
|
||||
for _, slice := range slices {
|
||||
if !InSliceByBinarySearch(slice, v, handler) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// AnyInAllSlices 判断元素是否在所有切片中都存在任意至少一个
|
||||
func AnyInAllSlices[S ~[]V, V any](slices []S, v []V, handler ComparisonHandler[V]) bool {
|
||||
if slices == nil {
|
||||
return false
|
||||
}
|
||||
for _, slice := range slices {
|
||||
if AnyInSlice(slice, v, handler) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// AnyInAllSlicesByBinarySearch 判断元素是否在所有切片中都存在任意至少一个，使用二分搜索
|
||||
func AnyInAllSlicesByBinarySearch[S ~[]V, V any](slices []S, v []V, handler ComparisonHandler[V]) bool {
|
||||
if slices == nil {
|
||||
return false
|
||||
}
|
||||
for _, slice := range slices {
|
||||
if AnyInSliceByBinarySearch(slice, v, handler) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// KeyInMap 判断 map 中是否包含某个 key
|
||||
func KeyInMap[M ~map[K]V, K comparable, V any](m M, key K) bool {
|
||||
_, ok := m[key]
|
||||
return ok
|
||||
}
|
||||
|
||||
// ValueInMap 判断 map 中是否包含某个 value
|
||||
func ValueInMap[M ~map[K]V, K comparable, V any](m M, value V, handler ComparisonHandler[V]) bool {
|
||||
if m == nil {
|
||||
return false
|
||||
}
|
||||
for _, v := range m {
|
||||
if handler(value, v) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// AllKeyInMap 判断 map 中是否包含所有 key
|
||||
func AllKeyInMap[M ~map[K]V, K comparable, V any](m M, keys ...K) bool {
|
||||
if m == nil {
|
||||
return false
|
||||
}
|
||||
for _, key := range keys {
|
||||
if !KeyInMap(m, key) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// AllValueInMap 判断 map 中是否包含所有 value
|
||||
func AllValueInMap[M ~map[K]V, K comparable, V any](m M, values []V, handler ComparisonHandler[V]) bool {
|
||||
if m == nil {
|
||||
return false
|
||||
}
|
||||
for _, value := range values {
|
||||
if !ValueInMap(m, value, handler) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// AnyKeyInMap 判断 map 中是否包含任意一个 key
|
||||
func AnyKeyInMap[M ~map[K]V, K comparable, V any](m M, keys ...K) bool {
|
||||
if m == nil {
|
||||
return false
|
||||
}
|
||||
for _, key := range keys {
|
||||
if KeyInMap(m, key) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// AnyValueInMap 判断 map 中是否包含任意一个 value
|
||||
func AnyValueInMap[M ~map[K]V, K comparable, V any](m M, values []V, handler ComparisonHandler[V]) bool {
|
||||
if m == nil {
|
||||
return false
|
||||
}
|
||||
for _, value := range values {
|
||||
if ValueInMap(m, value, handler) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// AllKeyInMaps 判断多个 map 中是否包含所有 key
|
||||
func AllKeyInMaps[M ~map[K]V, K comparable, V any](maps []M, keys ...K) bool {
|
||||
if maps == nil {
|
||||
return false
|
||||
}
|
||||
for _, m := range maps {
|
||||
if !AllKeyInMap(m, keys...) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// AllValueInMaps 判断多个 map 中是否包含所有 value
|
||||
func AllValueInMaps[M ~map[K]V, K comparable, V any](maps []M, values []V, handler ComparisonHandler[V]) bool {
|
||||
if maps == nil {
|
||||
return false
|
||||
}
|
||||
for _, m := range maps {
|
||||
if !AllValueInMap(m, values, handler) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// AnyKeyInMaps 判断多个 map 中是否包含任意一个 key
|
||||
func AnyKeyInMaps[M ~map[K]V, K comparable, V any](maps []M, keys ...K) bool {
|
||||
if maps == nil {
|
||||
return false
|
||||
}
|
||||
for _, m := range maps {
|
||||
if AnyKeyInMap(m, keys...) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// AnyValueInMaps 判断多个 map 中是否包含任意一个 value
|
||||
func AnyValueInMaps[M ~map[K]V, K comparable, V any](maps []M, values []V, handler ComparisonHandler[V]) bool {
|
||||
if maps == nil {
|
||||
return false
|
||||
}
|
||||
for _, m := range maps {
|
||||
if AnyValueInMap(m, values, handler) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// InAllMaps 判断元素是否在所有 map 中都存在
|
||||
func InAllMaps[M ~map[K]V, K comparable, V any](maps []M, key K) bool {
|
||||
if maps == nil {
|
||||
return false
|
||||
}
|
||||
for _, m := range maps {
|
||||
if !KeyInMap(m, key) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// AnyInAllMaps 判断元素是否在所有 map 中都存在任意至少一个
|
||||
func AnyInAllMaps[M ~map[K]V, K comparable, V any](maps []M, keys []K) bool {
|
||||
if maps == nil {
|
||||
return false
|
||||
}
|
||||
for _, m := range maps {
|
||||
if AnyKeyInMap(m, keys...) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
// Package sher 用于对 slice 和 map 操作的工具函数，将逐步替代 utils/slice 和 utils/map
|
||||
package sher
|
||||
|
|
@ -0,0 +1,137 @@
|
|||
package sher
|
||||
|
||||
// FilterOutByIndices 过滤切片中特定索引的元素，返回过滤后的切片
|
||||
func FilterOutByIndices[S ~[]V, V any](slice S, indices ...int) S {
|
||||
if slice == nil {
|
||||
return nil
|
||||
}
|
||||
if len(indices) == 0 {
|
||||
return slice
|
||||
}
|
||||
|
||||
excludeMap := make(map[int]bool)
|
||||
for _, ex := range indices {
|
||||
excludeMap[ex] = true
|
||||
}
|
||||
|
||||
validElements := make([]V, 0, len(slice)-len(excludeMap))
|
||||
for i, v := range slice {
|
||||
if !excludeMap[i] {
|
||||
validElements = append(validElements, v)
|
||||
}
|
||||
}
|
||||
|
||||
return validElements
|
||||
}
|
||||
|
||||
// FilterOutByCondition 过滤切片中符合条件的元素，返回过滤后的切片
|
||||
// - condition 的返回值为 true 时，将会过滤掉该元素
|
||||
func FilterOutByCondition[S ~[]V, V any](slice S, condition func(v V) bool) S {
|
||||
if slice == nil {
|
||||
return nil
|
||||
}
|
||||
if condition == nil {
|
||||
return slice
|
||||
}
|
||||
|
||||
validElements := make([]V, 0, len(slice))
|
||||
for _, v := range slice {
|
||||
if !condition(v) {
|
||||
validElements = append(validElements, v)
|
||||
}
|
||||
}
|
||||
|
||||
return validElements
|
||||
}
|
||||
|
||||
// FilterOutByKey 过滤 map 中特定的 key，返回过滤后的 map
|
||||
func FilterOutByKey[M ~map[K]V, K comparable, V any](m M, key K) M {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
validMap := make(M, len(m)-1)
|
||||
for k, v := range m {
|
||||
if k != key {
|
||||
validMap[k] = v
|
||||
}
|
||||
}
|
||||
|
||||
return validMap
|
||||
}
|
||||
|
||||
// FilterOutByValue 过滤 map 中特定的 value，返回过滤后的 map
|
||||
func FilterOutByValue[M ~map[K]V, K comparable, V any](m M, value V, handler ComparisonHandler[V]) M {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
validMap := make(M, len(m))
|
||||
for k, v := range m {
|
||||
if !handler(value, v) {
|
||||
validMap[k] = v
|
||||
}
|
||||
}
|
||||
|
||||
return validMap
|
||||
}
|
||||
|
||||
// FilterOutByKeys 过滤 map 中多个 key，返回过滤后的 map
|
||||
func FilterOutByKeys[M ~map[K]V, K comparable, V any](m M, keys ...K) M {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
if len(keys) == 0 {
|
||||
return m
|
||||
}
|
||||
|
||||
validMap := make(M, len(m)-len(keys))
|
||||
for k, v := range m {
|
||||
if !InSlice(keys, k, func(source, target K) bool {
|
||||
return source == target
|
||||
}) {
|
||||
validMap[k] = v
|
||||
}
|
||||
}
|
||||
|
||||
return validMap
|
||||
}
|
||||
|
||||
// FilterOutByValues 过滤 map 中多个 value，返回过滤后的 map
|
||||
func FilterOutByValues[M ~map[K]V, K comparable, V any](m M, values []V, handler ComparisonHandler[V]) M {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
if len(values) == 0 {
|
||||
return m
|
||||
}
|
||||
|
||||
validMap := make(M, len(m))
|
||||
for k, v := range m {
|
||||
if !InSlice(values, v, handler) {
|
||||
validMap[k] = v
|
||||
}
|
||||
}
|
||||
|
||||
return validMap
|
||||
}
|
||||
|
||||
// FilterOutByMap 过滤 map 中符合条件的元素，返回过滤后的 map
|
||||
// - condition 的返回值为 true 时，将会过滤掉该元素
|
||||
func FilterOutByMap[M ~map[K]V, K comparable, V any](m M, condition func(k K, v V) bool) M {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
if condition == nil {
|
||||
return m
|
||||
}
|
||||
|
||||
validMap := make(M, len(m))
|
||||
for k, v := range m {
|
||||
if condition(k, v) {
|
||||
validMap[k] = v
|
||||
}
|
||||
}
|
||||
|
||||
return validMap
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
package sher
|
||||
|
||||
import "github.com/kercylan98/minotaur/utils/generic"
|
||||
|
||||
// FindMinimumInSlice 获取切片中的最小值
|
||||
func FindMinimumInSlice[S ~[]V, V generic.Number](slice S, handler ComparisonHandler[V]) (result V) {
|
||||
if slice == nil {
|
||||
return
|
||||
}
|
||||
result = slice[0]
|
||||
for i := 1; i < len(slice); i++ {
|
||||
if handler(slice[i], result) {
|
||||
result = slice[i]
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// FindMaximumInSlice 获取切片中的最大值
|
||||
func FindMaximumInSlice[S ~[]V, V generic.Number](slice S, handler ComparisonHandler[V]) (result V) {
|
||||
if slice == nil {
|
||||
return
|
||||
}
|
||||
result = slice[0]
|
||||
for i := 1; i < len(slice); i++ {
|
||||
if handler(result, slice[i]) {
|
||||
result = slice[i]
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// FindMin2MaxInSlice 获取切片中的最小值和最大值
|
||||
func FindMin2MaxInSlice[S ~[]V, V generic.Number](slice S, handler ComparisonHandler[V]) (min, max V) {
|
||||
if slice == nil {
|
||||
return
|
||||
}
|
||||
min = slice[0]
|
||||
max = slice[0]
|
||||
for i := 1; i < len(slice); i++ {
|
||||
if handler(slice[i], min) {
|
||||
min = slice[i]
|
||||
}
|
||||
if handler(max, slice[i]) {
|
||||
max = slice[i]
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// FindMinFromMap 获取 map 中的最小值
|
||||
func FindMinFromMap[M ~map[K]V, K comparable, V generic.Number](m M, handler ComparisonHandler[V]) (result V) {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
for _, v := range m {
|
||||
if handler(v, result) {
|
||||
result = v
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// FindMaxFromMap 获取 map 中的最大值
|
||||
func FindMaxFromMap[M ~map[K]V, K comparable, V generic.Number](m M, handler ComparisonHandler[V]) (result V) {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
for _, v := range m {
|
||||
if handler(result, v) {
|
||||
result = v
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// FindMin2MaxFromMap 获取 map 中的最小值和最大值
|
||||
func FindMin2MaxFromMap[M ~map[K]V, K comparable, V generic.Number](m M, handler ComparisonHandler[V]) (min, max V) {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
for _, v := range m {
|
||||
if handler(v, min) {
|
||||
min = v
|
||||
}
|
||||
if handler(max, v) {
|
||||
max = v
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
package sher
|
||||
|
||||
// MergeSlices 合并切片
|
||||
func MergeSlices[S ~[]V, V any](slices ...S) (result S) {
|
||||
if len(slices) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
var length int
|
||||
for _, slice := range slices {
|
||||
length += len(slice)
|
||||
}
|
||||
|
||||
result = make(S, 0, length)
|
||||
for _, slice := range slices {
|
||||
result = append(result, slice...)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// MergeMaps 合并 map，当多个 map 中存在相同的 key 时，后面的 map 中的 key 将会覆盖前面的 map 中的 key
|
||||
func MergeMaps[M ~map[K]V, K comparable, V any](maps ...M) (result M) {
|
||||
if len(maps) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
var length int
|
||||
for _, m := range maps {
|
||||
length += len(m)
|
||||
}
|
||||
|
||||
result = make(M, length)
|
||||
for _, m := range maps {
|
||||
for k, v := range m {
|
||||
result[k] = v
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// MergeMapsWithSkip 合并 map，当多个 map 中存在相同的 key 时，后面的 map 中的 key 将会被跳过
|
||||
func MergeMapsWithSkip[M ~map[K]V, K comparable, V any](maps ...M) (result M) {
|
||||
if len(maps) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
result = make(M)
|
||||
for _, m := range maps {
|
||||
for k, v := range m {
|
||||
if _, ok := result[k]; !ok {
|
||||
result[k] = v
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
|
@ -0,0 +1,239 @@
|
|||
package sher
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/kercylan98/minotaur/utils/random"
|
||||
)
|
||||
|
||||
// ChooseRandomSliceElementRepeatN 获取切片中的 n 个随机元素，允许重复
|
||||
// - 如果 n 大于切片长度或小于 0 时将会发生 panic
|
||||
func ChooseRandomSliceElementRepeatN[S ~[]V, V any](slice S, n int) (result []V) {
|
||||
if slice == nil {
|
||||
return
|
||||
}
|
||||
if n > len(slice) || n < 0 {
|
||||
panic(fmt.Errorf("n is greater than the length of the slice or less than 0, n: %d, length: %d", n, len(slice)))
|
||||
}
|
||||
result = make([]V, n)
|
||||
for i := 0; i < n; i++ {
|
||||
result[i] = slice[random.Int(0, len(slice)-1)]
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ChooseRandomIndexRepeatN 获取切片中的 n 个随机元素的索引，允许重复
|
||||
// - 如果 n 大于切片长度或小于 0 时将会发生 panic
|
||||
func ChooseRandomIndexRepeatN[S ~[]V, V any](slice S, n int) (result []int) {
|
||||
if slice == nil {
|
||||
return
|
||||
}
|
||||
if n > len(slice) || n < 0 {
|
||||
panic(fmt.Errorf("n is greater than the length of the slice or less than 0, n: %d, length: %d", n, len(slice)))
|
||||
}
|
||||
result = make([]int, n)
|
||||
for i := 0; i < n; i++ {
|
||||
result[i] = random.Int(0, len(slice)-1)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ChooseRandomSliceElement 获取切片中的随机元素
|
||||
func ChooseRandomSliceElement[S ~[]V, V any](slice S) (v V) {
|
||||
if slice == nil {
|
||||
return
|
||||
}
|
||||
return slice[random.Int(0, len(slice)-1)]
|
||||
}
|
||||
|
||||
// ChooseRandomIndex 获取切片中的随机元素的索引
|
||||
func ChooseRandomIndex[S ~[]V, V any](slice S) (index int) {
|
||||
if slice == nil {
|
||||
return
|
||||
}
|
||||
return random.Int(0, len(slice)-1)
|
||||
}
|
||||
|
||||
// ChooseRandomSliceElementN 获取切片中的 n 个随机元素
|
||||
// - 如果 n 大于切片长度或小于 0 时将会发生 panic
|
||||
func ChooseRandomSliceElementN[S ~[]V, V any](slice S, n int) (result []V) {
|
||||
if slice == nil {
|
||||
return
|
||||
}
|
||||
if n > len(slice) || n < 0 {
|
||||
panic(fmt.Errorf("n is greater than the length of the slice or less than 0, n: %d, length: %d", n, len(slice)))
|
||||
}
|
||||
result = make([]V, n)
|
||||
for i := 0; i < n; i++ {
|
||||
result[i] = slice[random.Int(0, len(slice)-1)]
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ChooseRandomIndexN 获取切片中的 n 个随机元素的索引
|
||||
// - 如果 n 大于切片长度或小于 0 时将会发生 panic
|
||||
func ChooseRandomIndexN[S ~[]V, V any](slice S, n int) (result []int) {
|
||||
if slice == nil {
|
||||
return
|
||||
}
|
||||
if n > len(slice) || n < 0 {
|
||||
panic(fmt.Errorf("n is greater than the length of the slice or less than 0, n: %d, length: %d", n, len(slice)))
|
||||
}
|
||||
result = make([]int, n)
|
||||
for i := 0; i < n; i++ {
|
||||
result[i] = random.Int(0, len(slice)-1)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ChooseRandomMapKeyRepeatN 获取 map 中的 n 个随机 key，允许重复
|
||||
// - 如果 n 大于 map 长度或小于 0 时将会发生 panic
|
||||
func ChooseRandomMapKeyRepeatN[M ~map[K]V, K comparable, V any](m M, n int) (result []K) {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
if n > len(m) || n < 0 {
|
||||
panic(fmt.Errorf("n is greater than the length of the map or less than 0, n: %d, length: %d", n, len(m)))
|
||||
}
|
||||
result = make([]K, n)
|
||||
for i := 0; i < n; i++ {
|
||||
for k := range m {
|
||||
result[i] = k
|
||||
break
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ChooseRandomMapValueRepeatN 获取 map 中的 n 个随机 value，允许重复
|
||||
// - 如果 n 大于 map 长度或小于 0 时将会发生 panic
|
||||
func ChooseRandomMapValueRepeatN[M ~map[K]V, K comparable, V any](m M, n int) (result []V) {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
if n > len(m) || n < 0 {
|
||||
panic(fmt.Errorf("n is greater than the length of the map or less than 0, n: %d, length: %d", n, len(m)))
|
||||
}
|
||||
result = make([]V, n)
|
||||
for i := 0; i < n; i++ {
|
||||
for _, v := range m {
|
||||
result[i] = v
|
||||
break
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ChooseRandomMapKeyAndValueRepeatN 获取 map 中的 n 个随机 key 和 value，允许重复
|
||||
// - 如果 n 大于 map 长度或小于 0 时将会发生 panic
|
||||
func ChooseRandomMapKeyAndValueRepeatN[M ~map[K]V, K comparable, V any](m M, n int) M {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
if n > len(m) || n < 0 {
|
||||
panic(fmt.Errorf("n is greater than the length of the map or less than 0, n: %d, length: %d", n, len(m)))
|
||||
}
|
||||
result := make(M, n)
|
||||
for i := 0; i < n; i++ {
|
||||
for k, v := range m {
|
||||
result[k] = v
|
||||
break
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// ChooseRandomMapKey 获取 map 中的随机 key
|
||||
func ChooseRandomMapKey[M ~map[K]V, K comparable, V any](m M) (k K) {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
for k = range m {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ChooseRandomMapValue 获取 map 中的随机 value
|
||||
func ChooseRandomMapValue[M ~map[K]V, K comparable, V any](m M) (v V) {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
for _, v = range m {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ChooseRandomMapKeyN 获取 map 中的 n 个随机 key
|
||||
// - 如果 n 大于 map 长度或小于 0 时将会发生 panic
|
||||
func ChooseRandomMapKeyN[M ~map[K]V, K comparable, V any](m M, n int) (result []K) {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
if n > len(m) || n < 0 {
|
||||
panic(fmt.Errorf("n is greater than the length of the map or less than 0, n: %d, length: %d", n, len(m)))
|
||||
}
|
||||
result = make([]K, n)
|
||||
i := 0
|
||||
for k := range m {
|
||||
result[i] = k
|
||||
i++
|
||||
if i == n {
|
||||
break
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ChooseRandomMapValueN 获取 map 中的 n 个随机 value
|
||||
// - 如果 n 大于 map 长度或小于 0 时将会发生 panic
|
||||
func ChooseRandomMapValueN[M ~map[K]V, K comparable, V any](m M, n int) (result []V) {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
if n > len(m) || n < 0 {
|
||||
panic(fmt.Errorf("n is greater than the length of the map or less than 0, n: %d, length: %d", n, len(m)))
|
||||
}
|
||||
result = make([]V, n)
|
||||
i := 0
|
||||
for _, v := range m {
|
||||
result[i] = v
|
||||
i++
|
||||
if i == n {
|
||||
break
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ChooseRandomMapKeyAndValue 获取 map 中的随机 key 和 value
|
||||
func ChooseRandomMapKeyAndValue[M ~map[K]V, K comparable, V any](m M) (k K, v V) {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
for k, v = range m {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ChooseRandomMapKeyAndValueN 获取 map 中的 n 个随机 key 和 value
|
||||
// - 如果 n 大于 map 长度或小于 0 时将会发生 panic
|
||||
func ChooseRandomMapKeyAndValueN[M ~map[K]V, K comparable, V any](m M, n int) M {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
if n > len(m) || n < 0 {
|
||||
panic(fmt.Errorf("n is greater than the length of the map or less than 0, n: %d, length: %d", n, len(m)))
|
||||
}
|
||||
result := make(M, n)
|
||||
i := 0
|
||||
for k, v := range m {
|
||||
result[k] = v
|
||||
i++
|
||||
if i == n {
|
||||
break
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
package sher
|
||||
|
||||
import (
|
||||
"github.com/kercylan98/minotaur/utils/generic"
|
||||
"github.com/kercylan98/minotaur/utils/random"
|
||||
"sort"
|
||||
)
|
||||
|
||||
// Desc 对切片进行降序排序
|
||||
func Desc[S ~[]V, V any, Sort generic.Ordered](slice *S, getter func(index int) Sort) {
|
||||
sort.Slice(*slice, func(i, j int) bool {
|
||||
return getter(i) > getter(j)
|
||||
})
|
||||
}
|
||||
|
||||
// DescByClone 对切片进行降序排序，返回排序后的切片
|
||||
func DescByClone[S ~[]V, V any, Sort generic.Ordered](slice S, getter func(index int) Sort) S {
|
||||
result := CloneSlice(slice)
|
||||
Desc(&result, getter)
|
||||
return result
|
||||
|
||||
}
|
||||
|
||||
// Asc 对切片进行升序排序
|
||||
func Asc[S ~[]V, V any, Sort generic.Ordered](slice *S, getter func(index int) Sort) {
|
||||
sort.Slice(*slice, func(i, j int) bool {
|
||||
return getter(i) < getter(j)
|
||||
})
|
||||
}
|
||||
|
||||
// AscByClone 对切片进行升序排序，返回排序后的切片
|
||||
func AscByClone[S ~[]V, V any, Sort generic.Ordered](slice S, getter func(index int) Sort) S {
|
||||
result := CloneSlice(slice)
|
||||
Asc(&result, getter)
|
||||
return result
|
||||
}
|
||||
|
||||
// Shuffle 对切片进行随机排序
|
||||
func Shuffle[S ~[]V, V any](slice *S) {
|
||||
sort.Slice(*slice, func(i, j int) bool {
|
||||
return random.Int(0, 1) == 0
|
||||
})
|
||||
}
|
||||
|
||||
// ShuffleByClone 对切片进行随机排序，返回排序后的切片
|
||||
func ShuffleByClone[S ~[]V, V any](slice S) S {
|
||||
result := CloneSlice(slice)
|
||||
Shuffle(&result)
|
||||
return result
|
||||
}
|
||||
Loading…
Reference in New Issue