mapKit

package
v3.1.107 Latest Latest
Warning

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

 Go to latest Published: Nov 5, 2024 License: Apache-2.0 Imports: 12 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	NewAnyAnyMap func(safe ...bool) *gmap.AnyAnyMap = gmap.NewAnyAnyMap

	NewAnyAnyMapFrom func(data map[interface{}]interface{}, safe ...bool) *gmap.AnyAnyMap = gmap.NewAnyAnyMapFrom
)

map[interface{}]interface{}

View Source 
var (
	NewIntAnyMap func(safe ...bool) *gmap.IntAnyMap = gmap.NewIntAnyMap

	NewIntAnyMapFrom func(data map[int]interface{}, safe ...bool) *gmap.IntAnyMap = gmap.NewIntAnyMapFrom
)

map[int]interface{}

View Source 
var (
	NewStrAnyMap func(safe ...bool) *gmap.StrAnyMap = gmap.NewStrAnyMap

	NewStrAnyMapFrom func(data map[string]interface{}, safe ...bool) *gmap.StrAnyMap = gmap.NewStrAnyMapFrom
)

map[string]interface{}

View Source 
var (
	NewIntIntMap func(safe ...bool) *gmap.IntIntMap = gmap.NewIntIntMap

	NewIntIntMapFrom func(data map[int]int, safe ...bool) *gmap.IntIntMap = gmap.NewIntIntMapFrom
)

map[int]int

View Source 
var (
	NewStrStrMap func(safe ...bool) *gmap.StrStrMap = gmap.NewStrStrMap

	NewStrStrMapFrom func(data map[string]string, safe ...bool) *gmap.StrStrMap = gmap.NewStrStrMapFrom
)

map[string]string

View Source 
var (
	NewIntStrMap func(safe ...bool) *gmap.IntStrMap = gmap.NewIntStrMap

	NewIntStrMapFrom func(data map[int]string, safe ...bool) *gmap.IntStrMap = gmap.NewIntStrMapFrom
)

map[int]string

View Source 
var (
	NewStrIntMap func(safe ...bool) *gmap.StrIntMap = gmap.NewStrIntMap

	NewStrIntMapFrom func(data map[string]int, safe ...bool) *gmap.StrIntMap = gmap.NewStrIntMapFrom
)

map[string]int

View Source 
var (
	// NewListMap
	/*
	   使用场景: 当需要按输入顺序返回结果时使用ListMap.
	*/
	NewListMap func(safe ...bool) *gmap.ListMap = gmap.NewListMap

	NewListMapFrom func(data map[interface{}]interface{}, safe ...bool) *gmap.ListMap = gmap.NewListMapFrom
)

map[interface{}]interface{}

View Source 
var (
	// NewTreeMap
	/*
	   PS: 当需要让返回结果按照自然升序排列时使用TreeMap.

	   @param comparator e.g. gutil.ComparatorInt
	*/
	NewTreeMap func(comparator func(v1, v2 interface{}) int, safe ...bool) *gmap.TreeMap = gmap.NewTreeMap

	NewTreeMapFrom func(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, safe ...bool) *gmap.TreeMap = gmap.NewTreeMapFrom
)

map[interface{}]interface{}

Functions

func AssertNotEmpty 

func AssertNotEmpty[K comparable, V any](m map[K]V, name string) error

func Clear 

func Clear[K comparable, V any](m map[K]V)

Clear 清空所有map的键值对，clear后，我们将得到一个empty map

func ContainKeys 

func ContainKeys[K comparable, V any](m map[K]V, keys ...K) bool

ContainKeys 判断 map实例 中是否存在 所有指定的key.

@param m 可以为nil（此时返回值固定为 false） @param keys (1) 可以一个key都不传，此时将固定返回 true; 

(2) 多个key的情况下，只要有1个key不存在于 传参m 中，将返回false.

func Contains 

func Contains[K comparable, V any](m map[K]V, key K) bool

Contains 判断 map实例 中是否存在 指定的key.

@param m 可以为nil（此时返回值固定为false）

e.g. 

(map[string]interface{}(nil), "1") => false

func Copy 

func Copy[K comparable, V any](m map[K]V) map[K]V

Copy 浅拷贝

@param src 可以为nil @return 保底为空的map实例（不为nil）

func Decode 

func Decode(input interface{}, output interface{}) error

Decode 将 通用的map[string]interface{} 解码到对应的 Go结构体中 ，或者执行相反的操作。

PS: (1) 也可用于: map转map； (2) 字段标签(tag)不同于json，详见: https://mp.weixin.qq.com/s/n_AXYv-p_ev-q23mhpDkOg .

@param input structure（包括map） @param output 必须是（map或结构体的）指针

func DeepCopy 

func DeepCopy[K comparable, V any](m map[K]V) map[K]V

func Encode 

func Encode(obj interface{}) map[string]interface{}

Encode 结构体 => map[string]interface{}

!!!: 结构体存在匿名字段的情况，会转换为map[string]interface{}嵌套map[string]interface{}.(https://blog.csdn.net/qcrao/article/details/121279453)

PS: 一般情况下，需要使用 tag.

golang gorm 零值更新不生效问题处理 

https://blog.csdn.net/damanchen/article/details/124717553

@param obj (1) 结构体（实例||指针） 

(2) 不能为nil（否则会panic）

@return 必定不为nil

func EncodeWithTag 

func EncodeWithTag(obj interface{}, tag string) map[string]interface{}

func Get 

func Get[K comparable, V any](m map[K]V, key K) V

Get

@param m 可以为nil @param key 如果不存在对应的值，将返回值类型的零值

func GetBool 

func GetBool[K comparable, V any](m map[K]V, key K) (bool, error)

GetBool

@param m 可以为nil

func GetInt 

func GetInt[K comparable, V any](m map[K]V, key K) (int, error)

GetInt

@param m 可以为nil

func GetInt32 

func GetInt32[K comparable, V any](m map[K]V, key K) (int32, error)

GetInt32

@param m 可以为nil

func GetInt64 

func GetInt64[K comparable, V any](m map[K]V, key K) (int64, error)

GetInt64

@param m 可以为nil

func GetString 

func GetString[K comparable, V any](m map[K]V, key K) (string, error)

GetString

@param m 可以为nil

func Invert 

func Invert[K comparable, V comparable](in map[K]V) map[V]K

Invert 倒置（反转，交换key、value，交换键和值）

PS: 如果map包含重复值，则后续值将覆盖前一个值的属性赋值。

@param in 可以为nil（将返回空的map实例） @return 必定不为nil

e.g. 

m1 := lo.Invert(map[string]int{"a": 1, "b": 2})
fmt.Println(m1) // map[1:a 2:b]
m2 := lo.Invert(map[string]int{"a": 1, "b": 2, "c": 1})
fmt.Println(m2) // map[1:c 2:b] 或 map[1:a 2:b]（因为map是无序的）

func IsEmpty 

func IsEmpty[K comparable, V interface{}](m map[K]V) bool

func IsNotEmpty 

func IsNotEmpty[K comparable, V interface{}](m map[K]V) bool

func Keys 

func Keys[K comparable, V any](m map[K]V) []K

Keys creates an array of the map keys.

@param m 可以为nil @return 保底空的slice实例

func MapEntries 

func MapEntries[K1 comparable, V1 any, K2 comparable, V2 any](in map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2

MapEntries 修改map实例的 键类型（key）和值类型（value）

func MapKeys 

func MapKeys[K comparable, V any, R comparable](in map[K]V, iteratee func(value V, key K) R) map[R]V

MapKeys 修改map实例的 键类型（key）

func MapToSlice 

func MapToSlice[K comparable, V any, R any](m map[K]V, transform func(key K, value V) R) []R

MapToSlice map实例 => slice实例

@param m 可以为nil @param transform (1) 不能为nil（除非m == nil），否则会导致panic: runtime error: invalid memory address or nil pointer dereference 

(2) 传参: 一对键值，返回值: slice实例中的一个元素

@return 必定不为nil（保底为空的slice实例）

e.g. 

s := mapKit.MapToSlice[string, string, string](map[string]string{"1": "a"}, func(key string, value string) string {
	return key + value
})
fmt.Println(s) // [1a]

func MapValues 

func MapValues[K comparable, V any, R any](in map[K]V, iteratee func(value V, key K) R) map[K]R

MapValues 修改map实例的 值类型（value）

PS: (1) 不会修改传参in; (2) 返回的是一个新的map实例.

@return 必定不为nil

func Merge 

func Merge[K comparable, V any](maps ...map[K]V) map[K]V

Merge 合并多个map实例

PS: 存在key相同的情况，以最右边的为准.

@param maps (1)可以为nil 

(2)内部可以有nil（甚至全是nil）
(3)不会修改其中任何一个map实例

@return (1)保底为空的map实例（不为nil） 

(2)返回的是一个新的map实例

e.g. 

m := mapKit.Merge[string, int](
	map[string]int{"a": 1, "b": 2},
	map[string]int{"a": 10},
	map[string]int{"a": 100},
)
fmt.Println(m) // map[a:100 b:2]

func Obtain 

func Obtain[K comparable, V any](m map[K]V, key K) (V, bool)

Obtain

@return (1) 第1个返回值: 如果key存在于m中，为key对应的值；否则为V类型的零值. 

(2) 第2个返回值: key是否存在于m中.

e.g. 

m := map[string]interface{}{
	"a": 0,
	"b": 1,
}
fmt.Println(mapKit.Obtain(m, "a")) // 0 true
fmt.Println(mapKit.Obtain(m, "c")) // <nil> false

func Remove 

func Remove[K comparable, V any](m map[K]V, key K) (V, bool)

Remove

PS: (0) 内置函数delete(m map[Type]Type1, key Type): 如果 m == nil 或 m中不存在key，delete()不做任何操作; (1) 可能会修改传参m（移除条目的话），因为它是map类型； (2) 命名参考了 java.util.Map .

@param m 可以为nil @param key 可以在传参m中不存在 @return 被移除出map的条目的值（存在的话） + 传参m是否包含传参key

e.g. 

m := map[string]interface{}{
	"a": 0,
	"b": 1,
	"c": 2,
}

fmt.Println(mapKit.Remove(m, "b")) // 1 true
fmt.Println(m)                     // map[a:0 c:2]

func Set 

func Set[K comparable, V any](m map[K]V, key K, value V)

Set 设置值（或更新值）

@param m 不能为nil（否则会导致 panic: assignment to entry in nil map）

func SetSafely 

func SetSafely[K comparable, V any](m map[K]V, key K, value V) map[K]V

SetSafely 设置值（或更新值）

@param m 可以为nil @return 可能是一个新的map实例

func SetSafelyAndHandleOldValue 

func SetSafelyAndHandleOldValue[K comparable, V any](m map[K]V, key K, value V, handler func(v V) error) (map[K]V, error)

SetSafelyAndHandleOldValue 设置值（或更新值） && 处理旧的值（有的话）

@return 如果不为nil，说明处理旧的值失败，设置值的操作将失败

func Values 

func Values[K comparable, V any](m map[K]V) []V

Values creates an array of the map values.

@param m 可以为nil @return 保底空的slice实例

Types

type MapWithLock 

type MapWithLock[K comparable, V any] struct {
	gmutex.RWMutex

	// Map 并发不安全的
	Map map[K]V
}

func NewMapWithLock 

func NewMapWithLock[K comparable, V any]() *MapWithLock[K, V]

func (*MapWithLock[K, V]) Size 

func (m *MapWithLock[K, V]) Size() (size int)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.