以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档：https://pkg.go.dev/github.com/gogf/gf/v2/container/gmap
New创建并返回一个空的AnyAnyMap。参数safe用于指定是否使用并发安全的map，默认情况下为false。 New(safe ...bool) *Map
func ExampleNew() {
m := gmap.New()
// Add data.
m.Set("key1", "val1")
// Print size.
fmt.Println(m.Size())
addMap := make(map[interface{}]interface{})
addMap["key2"] = "val2"
addMap["key3"] = "val3"
addMap[1] = 1
fmt.Println(m.Values())
// Batch add data.
m.Sets(addMap)
// Gets the value of the corresponding key.
fmt.Println(m.Get("key3"))
// Get the value by key, or set it with given key-value if not exist.
fmt.Println(m.GetOrSet("key4", "val4"))
// Set key-value if the key does not exist, then return true; or else return false.
fmt.Println(m.SetIfNotExist("key3", "val3"))
// Remove key
m.Remove("key2")
fmt.Println(m.Keys())
// Batch remove keys.
m.Removes([]interface{}{"key1", 1})
fmt.Println(m.Keys())
// Contains checks whether a key exists.
fmt.Println(m.Contains("key3"))
// Flip exchanges key-value of the map, it will change key-value to value-key.
m.Flip()
fmt.Println(m.Map())
// Clear deletes all data of the map.
m.Clear()
fmt.Println(m.Size())
// May Output:
// 1
// [val1]
// val3
// val4
// false
// [key4 key1 key3 1]
// [key4 key3]
// true
// map[val3:key3 val4:key4]
// 0
} NewFrom使用给定map的数据创建并返回AnyAnyMap。 map将被设置为底层数据映射（无深度拷贝），在外部更改map时，可能会同时出现一些安全问题。可选参数safe指定是否在并发安全中使用此结构，默认情况下为false。 NewFrom(data map[interface{}]interface{}, safe ...bool) *Map func ExampleNewFrom() {
m := gmap.New()
m.Set("key1", "val1")
fmt.Println(m)
n := gmap.NewFrom(m.MapCopy(), true)
fmt.Println(n)
// Output:
// {"key1":"val1"}
// {"key1":"val1"}
} Iterator使用自定义回调函数f以只读方式迭代hashmap。如果f返回true，则继续迭代，返回false则停止。 Iterator(f func(k interface{}, v interface{}) bool) func ExampleAnyAnyMap_Iterator() {
m := gmap.New()
for i := 0; i < 10; i++ {
m.Set(i, i*2)
}
var totalKey, totalValue int
m.Iterator(func(k interface{}, v interface{}) bool {
totalKey += k.(int)
totalValue += v.(int)
return totalKey < 10
})
fmt.Println("totalKey:", totalKey)
fmt.Println("totalValue:", totalValue)
// May Output:
// totalKey: 11
// totalValue: 22
} Clone返回一个新的AnyAnyMap，其中包含当前map数据的副本。 Clone(safe ...bool) *AnyAnyMap
func ExampleAnyAnyMap_Clone() {
m := gmap.New()
m.Set("key1", "val1")
fmt.Println(m)
n := m.Clone()
fmt.Println(n)
// Output:
// {"key1":"val1"}
// {"key1":"val1"}
} Map 返回底层数据map。 Map() map[interface{}]interface{} func ExampleAnyAnyMap_Map() {
// non concurrent-safety, a pointer to the underlying data
m1 := gmap.New()
m1.Set("key1", "val1")
fmt.Println("m1:", m1)
n1 := m1.Map()
fmt.Println("before n1:", n1)
m1.Set("key1", "val2")
fmt.Println("after n1:", n1)
// concurrent-safety, copy of underlying data
m2 := gmap.New(true)
m2.Set("key1", "val1")
fmt.Println("m1:", m2)
n2 := m2.Map()
fmt.Println("before n2:", n2)
m2.Set("key1", "val2")
fmt.Println("after n2:", n2)
// Output:
// m1: {"key1":"val1"}
// before n1: map[key1:val1]
// after n1: map[key1:val2]
// m1: {"key1":"val1"}
// before n2: map[key1:val1]
// after n2: map[key1:val1]
} MapCopy返回map的数据的副本。 MapCopy() map[interface{}]interface{} func ExampleAnyAnyMap_MapCopy() {
m := gmap.New()
m.Set("key1", "val1")
m.Set("key2", "val2")
fmt.Println(m)
n := m.MapCopy()
fmt.Println(n)
// Output:
// {"key1":"val1","key2":"val2"}
// map[key1:val1 key2:val2]
} MapStrAny以map[string]interface{}的形式返回map的数据的副本。 MapStrAny() map[string]interface{} func ExampleAnyAnyMap_MapStrAny() {
m := gmap.New()
m.Set(1001, "val1")
m.Set(1002, "val2")
n := m.MapStrAny()
fmt.Println(n)
// Output:
// map[1001:val1 1002:val2]
} FilterEmpty删除值为空的所有键值对。如: 0, nil, false, "", len(slice/map/chan) == 0 这样的值被认为是空的。 FilterEmpty()
func ExampleAnyAnyMap_FilterEmpty() {
m := gmap.NewFrom(g.MapAnyAny{
"k1": "",
"k2": nil,
"k3": 0,
"k4": 1,
})
m.FilterEmpty()
fmt.Println(m.Map())
// Output:
// map[k4:1]
} FilterNil删除其值为nil的所有键值对。 FilterNil()
func ExampleAnyAnyMap_FilterNil() {
m := gmap.NewFrom(g.MapAnyAny{
"k1": "",
"k2": nil,
"k3": 0,
"k4": 1,
})
m.FilterNil()
fmt.Println(m.Map())
// May Output:
// map[k1: k3:0 k4:1]
} Set为map设置key/value。 Set(key interface{}, value interface{}) func ExampleAnyAnyMap_Set() {
m := gmap.New()
m.Set("key1", "val1")
fmt.Println(m)
// Output:
// {"key1":"val1"}
} Sets为map批量设置key/value。 Sets(data map[interface{}]interface{}) func ExampleAnyAnyMap_Sets() {
m := gmap.New()
addMap := make(map[interface{}]interface{})
addMap["key1"] = "val1"
addMap["key2"] = "val2"
addMap["key3"] = "val3"
m.Sets(addMap)
fmt.Println(m)
// Output:
// {"key1":"val1","key2":"val2","key3":"val3"}
} Search使用参数key搜索map。如果找到key，则返回其对应的键值，并且返回参数found为true，否则为false。 Search(key interface{}) (value interface{}, found bool) func ExampleAnyAnyMap_Search() {
m := gmap.New()
m.Set("key1", "val1")
value, found := m.Search("key1")
if found {
fmt.Println("find key1 value:", value)
}
value, found = m.Search("key2")
if !found {
fmt.Println("key2 not find")
}
// Output:
// find key1 value: val1
// key2 not find
} Get返回参数key对应的值value，如key不存在，则返回Nil。 Get(key interface{}) (value interface{}) func ExampleAnyAnyMap_Get() {
m := gmap.New()
m.Set("key1", "val1")
fmt.Println("key1 value:", m.Get("key1"))
fmt.Println("key2 value:", m.Get("key2"))
// Output:
// key1 value: val1
// key2 value: <nil>
} Pop从map中随机取出返回一个键值对，并在内部删除该键值对。 Pop() (key, value interface{}) func ExampleAnyAnyMap_Pop() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
"k2": "v2",
"k3": "v3",
"k4": "v4",
})
fmt.Println(m.Pop())
// May Output:
// k1 v1
} Pops从map中随机取出并删除size个键值对。如果size == -1，则删除并返回所有键值对。 Pops(size int) map[interface{}]interface{} func ExampleAnyAnyMap_Pops() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
"k2": "v2",
"k3": "v3",
"k4": "v4",
})
fmt.Println(m.Pops(-1))
fmt.Println("size:", m.Size())
m.Sets(g.MapAnyAny{
"k1": "v1",
"k2": "v2",
"k3": "v3",
"k4": "v4",
})
fmt.Println(m.Pops(2))
fmt.Println("size:", m.Size())
// May Output:
// map[k1:v1 k2:v2 k3:v3 k4:v4]
// size: 0
// map[k1:v1 k2:v2]
// size: 2
} GetOrSet如key存在，则返回value，如key不存在，使用key和value给map设置键值，然后返回该值。 GetOrSet(key interface{}, value interface{}) interface{} func ExampleAnyAnyMap_GetOrSet() {
m := gmap.New()
m.Set("key1", "val1")
fmt.Println(m.GetOrSet("key1", "NotExistValue"))
fmt.Println(m.GetOrSet("key2", "val2"))
// Output:
// val1
// val2
} GetOrSetFunc如key存在，则返回value，如key不存在，使用key和func f的返回值 给map设置键值，然后返回该值。 GetOrSetFunc(key interface{}, f func() interface{}) interface{} func ExampleAnyAnyMap_GetOrSetFunc() {
m := gmap.New()
m.Set("key1", "val1")
fmt.Println(m.GetOrSetFunc("key1", func() interface{} {
return "NotExistValue"
}))
fmt.Println(m.GetOrSetFunc("key2", func() interface{} {
return "NotExistValue"
}))
// Output:
// val1
// NotExistValue
} GetOrSetFunc如key存在，则返回value，如key不存在，使用key和func f的返回值 给map设置键值，然后返回该值。 GetOrSetFuncLock与GetOrSetFunc函数的不同之处在于它在写锁中执行函数f。 GetOrSetFuncLock(key interface{}, f func() interface{}) interface{} func ExampleAnyAnyMap_GetOrSetFuncLock() {
m := gmap.New()
m.Set("key1", "val1")
fmt.Println(m.GetOrSetFuncLock("key1", func() interface{} {
return "NotExistValue"
}))
fmt.Println(m.GetOrSetFuncLock("key2", func() interface{} {
return "NotExistValue"
}))
// Output:
// val1
// NotExistValue
} GetVar根据键名key查询并返回对应的键值，键值使用泛型类型*gvar.Var返回。 GetVar(key interface{}) *gvar.Var func ExampleAnyAnyMap_GetVar() {
m := gmap.New()
m.Set("key1", "val1")
fmt.Println(m.GetVar("key1"))
fmt.Println(m.GetVar("key2").IsNil())
// Output:
// val1
// true
} GetVarOrSet根据键名key查询并返回对应的键值。当对应的键值不存在时，使用value设置该键值，并返回查询/设置的键值。键值使用泛型类型*gvar.Var返回。 GetVarOrSet(key interface{}, value interface{}) *gvar.Var func ExampleAnyAnyMap_GetVarOrSet() {
m := gmap.New()
m.Set("key1", "val1")
fmt.Println(m.GetVarOrSet("key1", "NotExistValue"))
fmt.Println(m.GetVarOrSet("key2", "val2"))
// Output:
// val1
// val2
} GetVarOrSetFunc根据键名key查询并返回对应的键值。当对应的键值不存在时，使用func f的返回值设置该键值，并返回查询/设置的键值。键值使用泛型类型*gvar.Var返回。 GetVarOrSetFunc(key interface{}, f func() interface{}) *gvar.Var func ExampleAnyAnyMap_GetVarOrSetFunc() {
m := gmap.New()
m.Set("key1", "val1")
fmt.Println(m.GetVarOrSetFunc("key1", func() interface{} {
return "NotExistValue"
}))
fmt.Println(m.GetVarOrSetFunc("key2", func() interface{} {
return "NotExistValue"
}))
// Output:
// val1
// NotExistValue
} GetVarOrSetFuncLock根据键名key查询并返回对应的键值。当对应的键值不存在时，使用func f的返回值设置该键值，并返回查询/设置的键值。键值使用泛型类型*gvar.Var返回。 GetVarOrSetFuncLock与GetVarOrSetFunc函数的不同之处在于它在写锁中执行函数f。即当有多个goroutine同时调用该方法时，函数f将会在执行之前被阻塞。 GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gvar.Var func ExampleAnyAnyMap_GetVarOrSetFuncLock() {
m := gmap.New()
m.Set("key1", "val1")
fmt.Println(m.GetVarOrSetFuncLock("key1", func() interface{} {
return "NotExistValue"
}))
fmt.Println(m.GetVarOrSetFuncLock("key2", func() interface{} {
return "NotExistValue"
}))
// Output:
// val1
// NotExistValue
} key不存在，则SetIfNotExist为map设置值键值对key/value，并且返回true。如果key存在，则返回false，而value将被忽略。 SetIfNotExist(key interface{}, value interface{}) bool func ExampleAnyAnyMap_SetIfNotExist() {
var m gmap.Map
fmt.Println(m.SetIfNotExist("k1", "v1"))
fmt.Println(m.SetIfNotExist("k1", "v1"))
fmt.Println(m.Map())
// Output:
// true
// false
// map[k1:v1]
} key不存在，则SetIfNotExistFunc为map设置值为函数f的返回值，并且返回true。如果key存在，则返回false，并且value将被忽略。 SetIfNotExistFunc(key interface{}, f func() interface{}) bool func ExampleAnyAnyMap_SetIfNotExistFunc() {
var m gmap.Map
fmt.Println(m.SetIfNotExistFunc("k1", func() interface{} {
return "v1"
}))
fmt.Println(m.SetIfNotExistFunc("k1", func() interface{} {
return "v1"
}))
fmt.Println(m.Map())
// Output:
// true
// false
// map[k1:v1]
} key不存在，则SetIfNotExistFunc为map设置值为func c的返回值，然后返回true。如果key存在，则返回false，而value将被忽略。 SetIfNotExistFuncLock与SetIfNotExistFunc函数的不同之处在于它在mutex.Lock中执行函数f。 SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool func ExampleAnyAnyMap_SetIfNotExistFuncLock() {
var m gmap.Map
fmt.Println(m.SetIfNotExistFuncLock("k1", func() interface{} {
return "v1"
}))
fmt.Println(m.SetIfNotExistFuncLock("k1", func() interface{} {
return "v1"
}))
fmt.Println(m.Map())
// Output:
// true
// false
// map[k1:v1]
} key从map中删除value，并返回此删除的value。 Remove(key interface{}) (value interface{}) func ExampleAnyAnyMap_Remove() {
var m gmap.Map
m.Set("k1", "v1")
fmt.Println(m.Remove("k1"))
fmt.Println(m.Remove("k2"))
// Output:
// v1
// <nil>
} Removes按给定的key批量删除map的value。 Removes(keys []interface{}) func ExampleAnyAnyMap_Removes() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
"k2": "v2",
"k3": "v3",
"k4": "v4",
})
removeList := make([]interface{}, 2)
removeList = append(removeList, "k1")
removeList = append(removeList, "k2")
m.Removes(removeList)
fmt.Println(m.Map())
// Output:
// map[k3:v3 k4:v4]
} Keys将map的所有key作为slice返回。 Keys() []interface{} func ExampleAnyAnyMap_Keys() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
"k2": "v2",
"k3": "v3",
"k4": "v4",
})
fmt.Println(m.Keys())
// Output:
// [k1 k2 k3 k4]
} Values将map的所有value作为slice返回。 Values() []interface{} func ExampleAnyAnyMap_Values() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
"k2": "v2",
"k3": "v3",
"k4": "v4",
})
fmt.Println(m.Values())
// May Output:
// [v1 v2 v3 v4]
} Contains检查key是否存在。如果key存在，则返回true，否则返回false。 interface{}，因此匹配判断需要保证类型和数值一致。 Contains(key interface{}) bool func ExampleAnyAnyMap_Contains() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
"k2": "v2",
"k3": "v3",
"k4": "v4",
})
fmt.Println(m.Contains("k1"))
fmt.Println(m.Contains("k5"))
// Output:
// true
// false
} Size返回map的大小。 Size() int
func ExampleAnyAnyMap_Size() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
"k2": "v2",
"k3": "v3",
"k4": "v4",
})
fmt.Println(m.Size())
// Output:
// 4
} IsEmpty检查map是否为空。如果map为空，则返回true，否则返回false。 IsEmpty() bool
func ExampleAnyAnyMap_IsEmpty() {
var m gmap.Map
fmt.Println(m.IsEmpty())
m.Set("k1", "v1")
fmt.Println(m.IsEmpty())
// Output:
// true
// false
} Clear删除map的所有数据。 Clear()
func ExampleAnyAnyMap_Clear() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
"k2": "v2",
"k3": "v3",
"k4": "v4",
})
m.Clear()
fmt.Println(m.Map())
// Output:
// map[]
} Replace用给定的data完整替换map的value。 Replace(data map[interface{}]interface{}) func ExampleAnyAnyMap_Replace() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
})
var n gmap.Map
n.Sets(g.MapAnyAny{
"k2": "v2",
})
fmt.Println(m.Map())
m.Replace(n.Map())
fmt.Println(m.Map())
n.Set("k2", "v1")
fmt.Println(m.Map())
// Output:
// map[k1:v1]
// map[k2:v2]
// map[k2:v1]
} LockFunc在写锁中执行函数f。 LockFunc(f func(m map[interface{}]interface{})) func ExampleAnyAnyMap_LockFunc() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": 1,
"k2": 2,
"k3": 3,
"k4": 4,
})
m.LockFunc(func(m map[interface{}]interface{}) {
totalValue := 0
for _, v := range m {
totalValue += v.(int)
}
fmt.Println("totalValue:", totalValue)
})
// Output:
// totalValue: 10
} RLockFunc在读锁中执行函数f。 RLockFunc(f func(m map[interface{}]interface{})) func ExampleAnyAnyMap_RLockFunc() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": 1,
"k2": 2,
"k3": 3,
"k4": 4,
})
m.RLockFunc(func(m map[interface{}]interface{}) {
totalValue := 0
for _, v := range m {
totalValue += v.(int)
}
fmt.Println("totalValue:", totalValue)
})
// Output:
// totalValue: 10
} Flip将map的key与value进行交换。 Flip()
func ExampleAnyAnyMap_Flip() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
})
m.Flip()
fmt.Println(m.Map())
// Output:
// map[v1:k1]
} Merge合并两个AnyAnyMap。入参map将合并到原map中。 Merge(other *AnyAnyMap)
func ExampleAnyAnyMap_Merge() {
var m1, m2 gmap.Map
m1.Set("key1", "val1")
m2.Set("key2", "val2")
m1.Merge(&m2)
fmt.Println(m1.Map())
// May Output:
// map[key1:val1 key2:val2]
} String以字符串形式返回map。 String() string
func ExampleAnyAnyMap_String() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
})
fmt.Println(m.String())
// Output:
// {"k1":"v1"}
} MarshalJSON实现json.Marshal的接口。 MarshalJSON() ([]byte, error)
func ExampleAnyAnyMap_MarshalJSON() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
"k2": "v2",
"k3": "v3",
"k4": "v4",
})
bytes, err := m.MarshalJSON()
if err == nil {
fmt.Println(gconv.String(bytes))
}
// Output:
// {"k1":"v1","k2":"v2","k3":"v3","k4":"v4"}
} UnmarshalJSON实现了json.Unmarshal的接口。 UnmarshalJSON(b []byte) error
func ExampleAnyAnyMap_UnmarshalJSON() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
"k2": "v2",
"k3": "v3",
"k4": "v4",
})
var n gmap.Map
err := n.UnmarshalJSON(gconv.Bytes(m.String()))
if err == nil {
fmt.Println(n.Map())
}
// Output:
// map[k1:v1 k2:v2 k3:v3 k4:v4]
} UnmarshalValue是一个接口实现，它通过任意类型的变量初始化当前map。 UnmarshalValue(value interface{}) (err error) func ExampleAnyAnyMap_UnmarshalValue() {
var m gmap.Map
m.Sets(g.MapAnyAny{
"k1": "v1",
"k2": "v2",
"k3": "v3",
"k4": "v4",
})
var n gmap.Map
err := n.UnmarshalValue(m.String())
if err == nil {
fmt.Println(n.Map())
}
// Output:
// map[k1:v1 k2:v2 k3:v3 k4:v4]
}