mirror of
https://github.com/openimsdk/open-im-server.git
synced 2025-05-06 02:23:10 +08:00
1
This commit is contained in:
parent
94b0e60e83
commit
778e3e5cd2
@ -4,12 +4,12 @@ import (
|
|||||||
"sort"
|
"sort"
|
||||||
)
|
)
|
||||||
|
|
||||||
// DistinctAny 切片去重
|
// DistinctAny remove duplicate elements
|
||||||
func DistinctAny[T any, V comparable](ts []T, fn func(t T) V) []T {
|
func DistinctAny[E any, K comparable](es []E, fn func(e E) K) []E {
|
||||||
v := make([]T, 0, len(ts))
|
v := make([]E, 0, len(es))
|
||||||
tmp := map[V]struct{}{}
|
tmp := map[K]struct{}{}
|
||||||
for i := 0; i < len(ts); i++ {
|
for i := 0; i < len(es); i++ {
|
||||||
t := ts[i]
|
t := es[i]
|
||||||
k := fn(t)
|
k := fn(t)
|
||||||
if _, ok := tmp[k]; !ok {
|
if _, ok := tmp[k]; !ok {
|
||||||
tmp[k] = struct{}{}
|
tmp[k] = struct{}{}
|
||||||
@ -19,80 +19,204 @@ func DistinctAny[T any, V comparable](ts []T, fn func(t T) V) []T {
|
|||||||
return v
|
return v
|
||||||
}
|
}
|
||||||
|
|
||||||
// Distinct 切片去重
|
// Distinct remove duplicate elements
|
||||||
func Distinct[T comparable](ts []T) []T {
|
func Distinct[T comparable](ts []T) []T {
|
||||||
return DistinctAny(ts, func(t T) T {
|
return DistinctAny(ts, func(t T) T {
|
||||||
return t
|
return t
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
// DeleteAt 删除切片元素, 支持负数删除倒数第几个
|
// DeleteAt delete slice element, support negative number to delete the penultimate
|
||||||
func DeleteAt[T any](ts []T, index ...int) []T {
|
func DeleteAt[E any](es []E, index ...int) []E {
|
||||||
switch len(index) {
|
switch len(index) {
|
||||||
case 0:
|
case 0:
|
||||||
return ts
|
return es
|
||||||
case 1:
|
case 1:
|
||||||
i := index[0]
|
i := index[0]
|
||||||
if i < 0 {
|
if i < 0 {
|
||||||
i = len(ts) + i
|
i = len(es) + i
|
||||||
}
|
}
|
||||||
if len(ts) <= i {
|
if len(es) <= i {
|
||||||
return ts
|
return es
|
||||||
}
|
}
|
||||||
return append(ts[:i], ts[i+1:]...)
|
return append(es[:i], es[i+1:]...)
|
||||||
default:
|
default:
|
||||||
tmp := make(map[int]struct{})
|
tmp := make(map[int]struct{})
|
||||||
for _, i := range index {
|
for _, i := range index {
|
||||||
if i < 0 {
|
if i < 0 {
|
||||||
i = len(ts) + i
|
i = len(es) + i
|
||||||
}
|
}
|
||||||
tmp[i] = struct{}{}
|
tmp[i] = struct{}{}
|
||||||
}
|
}
|
||||||
v := make([]T, 0, len(ts))
|
v := make([]E, 0, len(es))
|
||||||
for i := 0; i < len(ts); i++ {
|
for i := 0; i < len(es); i++ {
|
||||||
if _, ok := tmp[i]; !ok {
|
if _, ok := tmp[i]; !ok {
|
||||||
v = append(v, ts[i])
|
v = append(v, es[i])
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return v
|
return v
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// IndexAny 获取元素所在的下标
|
// IndexAny get the index of the element
|
||||||
func IndexAny[T any, V comparable](ts []T, t T, fn func(t T) V) int {
|
func IndexAny[E any, K comparable](es []E, e E, fn func(e E) K) int {
|
||||||
k := fn(t)
|
k := fn(e)
|
||||||
for i := 0; i < len(ts); i++ {
|
for i := 0; i < len(es); i++ {
|
||||||
if fn(ts[i]) == k {
|
if fn(es[i]) == k {
|
||||||
return i
|
return i
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return -1
|
return -1
|
||||||
}
|
}
|
||||||
|
|
||||||
// IndexOf 可比较的元素index下标
|
// IndexOf get the index of the element
|
||||||
func IndexOf[T comparable](ts []T, t T) int {
|
func IndexOf[E comparable](es []E, e E) int {
|
||||||
return IndexAny(ts, t, func(t T) T {
|
return IndexAny(es, e, func(t E) E {
|
||||||
return t
|
return t
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
// IsContain 是否包含元素
|
// Contain include element or not
|
||||||
func IsContain[T comparable](ts []T, t T) bool {
|
func Contain[E comparable](es []E, e E) bool {
|
||||||
return IndexOf(ts, t) >= 0
|
return IndexOf(es, e) >= 0
|
||||||
}
|
}
|
||||||
|
|
||||||
// SliceToMap 切片转map
|
// SliceToMapOkAny slice to map
|
||||||
func SliceToMap[T any, K comparable](ts []T, fn func(t T) K) map[K]T {
|
func SliceToMapOkAny[E any, K comparable, V any](es []E, fn func(e E) (K, V, bool)) map[K]V {
|
||||||
kv := make(map[K]T)
|
kv := make(map[K]V)
|
||||||
for i := 0; i < len(ts); i++ {
|
for i := 0; i < len(es); i++ {
|
||||||
t := ts[i]
|
t := es[i]
|
||||||
k := fn(t)
|
if k, v, ok := fn(t); ok {
|
||||||
kv[k] = t
|
kv[k] = v
|
||||||
|
}
|
||||||
}
|
}
|
||||||
return kv
|
return kv
|
||||||
}
|
}
|
||||||
|
|
||||||
// MapKey map获取所有key
|
// SliceToMapAny slice to map
|
||||||
|
func SliceToMapAny[E any, K comparable, V any](es []E, fn func(e E) (K, V)) map[K]V {
|
||||||
|
return SliceToMapOkAny(es, func(e E) (K, V, bool) {
|
||||||
|
k, v := fn(e)
|
||||||
|
return k, v, true
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// SliceToMap slice to map
|
||||||
|
func SliceToMap[E any, K comparable](es []E, fn func(e E) K) map[K]E {
|
||||||
|
return SliceToMapOkAny[E, K, E](es, func(e E) (K, E, bool) {
|
||||||
|
k := fn(e)
|
||||||
|
return k, e, true
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// SliceSetAny slice to map[K]struct{}
|
||||||
|
func SliceSetAny[E any, K comparable](es []E, fn func(e E) K) map[K]struct{} {
|
||||||
|
return SliceToMapAny(es, func(e E) (K, struct{}) {
|
||||||
|
return fn(e), struct{}{}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// SliceSet slice to map[E]struct{}
|
||||||
|
func SliceSet[E comparable](es []E) map[E]struct{} {
|
||||||
|
return SliceSetAny(es, func(e E) E {
|
||||||
|
return e
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// HasKey get whether the map contains key
|
||||||
|
func HasKey[K comparable, V any](m map[K]V, k K) bool {
|
||||||
|
if m == nil {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
_, ok := m[k]
|
||||||
|
return ok
|
||||||
|
}
|
||||||
|
|
||||||
|
// Min get minimum value
|
||||||
|
func Min[E Ordered](e ...E) E {
|
||||||
|
v := e[0]
|
||||||
|
for _, t := range e[1:] {
|
||||||
|
if v > t {
|
||||||
|
v = t
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
|
// Max get maximum value
|
||||||
|
func Max[E Ordered](e ...E) E {
|
||||||
|
v := e[0]
|
||||||
|
for _, t := range e[1:] {
|
||||||
|
if v < t {
|
||||||
|
v = t
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
|
// BothExistAny get elements common to multiple slices
|
||||||
|
func BothExistAny[E any, K comparable](es [][]E, fn func(e E) K) []E {
|
||||||
|
if len(es) == 0 {
|
||||||
|
return []E{}
|
||||||
|
}
|
||||||
|
var idx int
|
||||||
|
ei := make([]map[K]E, len(es))
|
||||||
|
for i := 0; i < len(ei); i++ {
|
||||||
|
e := es[i]
|
||||||
|
if len(e) == 0 {
|
||||||
|
return []E{}
|
||||||
|
}
|
||||||
|
kv := make(map[K]E)
|
||||||
|
for j := 0; j < len(e); j++ {
|
||||||
|
t := e[j]
|
||||||
|
k := fn(t)
|
||||||
|
kv[k] = t
|
||||||
|
}
|
||||||
|
ei[i] = kv
|
||||||
|
if len(kv) < len(ei[idx]) {
|
||||||
|
idx = i
|
||||||
|
}
|
||||||
|
}
|
||||||
|
v := make([]E, 0, len(ei[idx]))
|
||||||
|
for k := range ei[idx] {
|
||||||
|
all := true
|
||||||
|
for i := 0; i < len(ei); i++ {
|
||||||
|
if i == idx {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if _, ok := ei[i][k]; !ok {
|
||||||
|
all = false
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !all {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
v = append(v, ei[idx][k])
|
||||||
|
}
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
|
// BothExist get elements common to multiple slices
|
||||||
|
func BothExist[E comparable](es ...[]E) []E {
|
||||||
|
return BothExistAny(es, func(e E) E {
|
||||||
|
return e
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// CompleteAny complete inclusion
|
||||||
|
func CompleteAny[K comparable, E any](ks []K, es []E, fn func(e E) K) bool {
|
||||||
|
a := SliceSetAny(es, fn)
|
||||||
|
for k := range SliceSet(ks) {
|
||||||
|
if !HasKey(a, k) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
delete(a, k)
|
||||||
|
}
|
||||||
|
return len(a) == 0
|
||||||
|
}
|
||||||
|
|
||||||
|
// MapKey get map keys
|
||||||
func MapKey[K comparable, V any](kv map[K]V) []K {
|
func MapKey[K comparable, V any](kv map[K]V) []K {
|
||||||
ks := make([]K, 0, len(kv))
|
ks := make([]K, 0, len(kv))
|
||||||
for k := range kv {
|
for k := range kv {
|
||||||
@ -101,7 +225,7 @@ func MapKey[K comparable, V any](kv map[K]V) []K {
|
|||||||
return ks
|
return ks
|
||||||
}
|
}
|
||||||
|
|
||||||
// MapValue map获取所有key
|
// MapValue get map values
|
||||||
func MapValue[K comparable, V any](kv map[K]V) []V {
|
func MapValue[K comparable, V any](kv map[K]V) []V {
|
||||||
vs := make([]V, 0, len(kv))
|
vs := make([]V, 0, len(kv))
|
||||||
for k := range kv {
|
for k := range kv {
|
||||||
@ -110,43 +234,44 @@ func MapValue[K comparable, V any](kv map[K]V) []V {
|
|||||||
return vs
|
return vs
|
||||||
}
|
}
|
||||||
|
|
||||||
// Sort 排序
|
// Sort basic type sorting
|
||||||
func Sort[T Ordered](ts []T, asc bool) []T {
|
func Sort[E Ordered](es []E, asc bool) []E {
|
||||||
SortAny(ts, func(a, b T) bool {
|
SortAny(es, func(a, b E) bool {
|
||||||
if asc {
|
if asc {
|
||||||
return a < b
|
return a < b
|
||||||
} else {
|
} else {
|
||||||
return a > b
|
return a > b
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
return ts
|
return es
|
||||||
}
|
}
|
||||||
|
|
||||||
// SortAny 排序
|
// SortAny custom sort method
|
||||||
func SortAny[T any](ts []T, fn func(a, b T) bool) {
|
func SortAny[E any](es []E, fn func(a, b E) bool) {
|
||||||
sort.Sort(&sortSlice[T]{
|
sort.Sort(&sortSlice[E]{
|
||||||
ts: ts,
|
ts: es,
|
||||||
fn: fn,
|
fn: fn,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
type sortSlice[T any] struct {
|
type sortSlice[E any] struct {
|
||||||
ts []T
|
ts []E
|
||||||
fn func(a, b T) bool
|
fn func(a, b E) bool
|
||||||
}
|
}
|
||||||
|
|
||||||
func (o *sortSlice[T]) Len() int {
|
func (o *sortSlice[E]) Len() int {
|
||||||
return len(o.ts)
|
return len(o.ts)
|
||||||
}
|
}
|
||||||
|
|
||||||
func (o *sortSlice[T]) Less(i, j int) bool {
|
func (o *sortSlice[E]) Less(i, j int) bool {
|
||||||
return o.fn(o.ts[i], o.ts[j])
|
return o.fn(o.ts[i], o.ts[j])
|
||||||
}
|
}
|
||||||
|
|
||||||
func (o *sortSlice[T]) Swap(i, j int) {
|
func (o *sortSlice[E]) Swap(i, j int) {
|
||||||
o.ts[i], o.ts[j] = o.ts[j], o.ts[i]
|
o.ts[i], o.ts[j] = o.ts[j], o.ts[i]
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Ordered types that can be sorted
|
||||||
type Ordered interface {
|
type Ordered interface {
|
||||||
~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~float32 | ~float64 | ~string
|
~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~float32 | ~float64 | ~string
|
||||||
}
|
}
|
||||||
|
@ -46,5 +46,39 @@ func TestIndexOf(t *testing.T) {
|
|||||||
func TestSort(t *testing.T) {
|
func TestSort(t *testing.T) {
|
||||||
arr := []int{1, 1, 1, 4, 4, 5, 2, 3, 3, 3, 6}
|
arr := []int{1, 1, 1, 4, 4, 5, 2, 3, 3, 3, 6}
|
||||||
fmt.Println(Sort(arr, false))
|
fmt.Println(Sort(arr, false))
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestBothExist(t *testing.T) {
|
||||||
|
arr1 := []int{1, 1, 1, 4, 4, 5, 2, 3, 3, 3, 6}
|
||||||
|
arr2 := []int{6, 1, 3}
|
||||||
|
arr3 := []int{5, 1, 3, 6}
|
||||||
|
fmt.Println(BothExist(arr1, arr2, arr3))
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestCompleteAny(t *testing.T) {
|
||||||
|
type Item struct {
|
||||||
|
ID int
|
||||||
|
Value string
|
||||||
|
}
|
||||||
|
|
||||||
|
ids := []int{1, 2, 3, 4, 5, 6, 7, 8}
|
||||||
|
|
||||||
|
var list []Item
|
||||||
|
|
||||||
|
for _, id := range ids {
|
||||||
|
list = append(list, Item{
|
||||||
|
ID: id,
|
||||||
|
Value: fmt.Sprintf("%d", id*1000),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
list = DeleteAt(list, -1)
|
||||||
|
ids = DeleteAt(ids, -1)
|
||||||
|
|
||||||
|
ok := CompleteAny(ids, list, func(t Item) int {
|
||||||
|
return t.ID
|
||||||
|
})
|
||||||
|
|
||||||
|
fmt.Printf("%+v\n", ok)
|
||||||
|
|
||||||
}
|
}
|
||||||
|
Loading…
x
Reference in New Issue
Block a user