@colin4k1024/tsp 2.4.0

package/skills/goframe-v2/references//347/273/204/344/273/266/345/210/227/350/241/250//346/225/260/346/215/256/347/273/223/346/236/204//345/255/227/345/205/270/347/261/273/345/236/213-gmap//345/255/227/345/205/270/347/261/273/345/236/213-/346/226/271/346/263/225/344/273/213/347/273/215.md

@@ -0,0 +1,1320 @@
+:::tip
+以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档： [https://pkg.go.dev/github.com/gogf/gf/v2/container/gmap](https://pkg.go.dev/github.com/gogf/gf/v2/container/gmap)
+:::
+## `New`
+
+- 说明： `New` 创建并返回一个空的 `AnyAnyMap`。参数 `safe` 用于指定是否使用并发安全的 `map`，默认情况下为 `false`。
+
+- 格式：
+
+```go
+New(safe ...bool) *Map
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `NewFrom` 使用给定 `map` 的数据创建并返回 `AnyAnyMap`。
+
+- 注意：入参 `map` 将被设置为底层数据映射（无深度拷贝），在外部更改 `map` 时，可能会同时出现一些安全问题。可选参数 `safe` 指定是否在并发安全中使用此结构，默认情况下为 `false`。
+
+- 格式：
+
+```go
+NewFrom(data map[interface{}]interface{}, safe ...bool) *Map
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Iterator` 使用自定义回调函数 `f` 以只读方式迭代 `hashmap`。如果 `f` 返回 `true`，则继续迭代，返回 `false` 则停止。
+
+- 格式：
+
+```go
+Iterator(f func(k interface{}, v interface{}) bool)
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Clone` 返回一个新的 `AnyAnyMap`，其中包含当前 `map` 数据的副本。
+
+- 格式：
+
+```go
+Clone(safe ...bool) *AnyAnyMap
+```
+
+- 示例：
+
+```go
+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`。
+
+- 注意：如果在并发安全中，它将返回底层数据的副本，否则返回指向底层数据的指针。
+
+- 格式：
+
+```go
+Map() map[interface{}]interface{}
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `MapCopy` 返回 `map` 的数据的副本。
+
+- 格式：
+
+```go
+MapCopy() map[interface{}]interface{}
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `MapStrAny` 以 `map[string]interface{}` 的形式返回 `map` 的数据的副本。
+
+- 格式：
+
+```go
+MapStrAny() map[string]interface{}
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `FilterEmpty` 删除值为空的所有键值对。如: `0`, `nil`, `false`, `""`, `len(slice/map/chan) == 0` 这样的值被认为是空的。
+
+- 格式：
+
+```go
+FilterEmpty()
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `FilterNil` 删除其值为 `nil` 的所有键值对。
+
+- 格式：
+
+```go
+FilterNil()
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Set` 为 `map` 设置 `key/value`。
+
+- 格式：
+
+```go
+Set(key interface{}, value interface{})
+```
+
+- 示例：
+
+```go
+func ExampleAnyAnyMap_Set() {
+      m := gmap.New()
+
+      m.Set("key1", "val1")
+      fmt.Println(m)
+
+      // Output:
+      // {"key1":"val1"}
+}
+```
+
+## `Sets`
+
+- 说明： `Sets` 为 `map` 批量设置 `key/` `value`。
+
+- 格式：
+
+```go
+Sets(data map[interface{}]interface{})
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Search` 使用参数 `key` 搜索 `map`。如果找到 `key`，则返回其对应的键值，并且返回参数 `found` 为 `true`，否则为 `false`。
+
+- 格式：
+
+```go
+Search(key interface{}) (value interface{}, found bool)
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Get` 返回参数 `key` 对应的值 `value`，如 `key` 不存在，则返回 `Nil`。
+
+- 格式：
+
+```go
+Get(key interface{}) (value interface{})
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Pop` 从 `map` 中随机取出返回一个键值对，并在内部删除该键值对。
+
+- 格式：
+
+```go
+Pop() (key, value interface{})
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Pops` 从 `map` 中随机取出并删除 `size` 个键值对。如果 `size == -1`，则删除并返回所有键值对。
+
+- 格式：
+
+```go
+Pops(size int) map[interface{}]interface{}
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `GetOrSet` 如 `key` 存在，则返回 `value`，如 `key` 不存在，使用 `key` 和 `value` 给 `map` 设置键值，然后返回该值。
+
+- 格式：
+
+```go
+GetOrSet(key interface{}, value interface{}) interface{}
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `GetOrSetFunc` 如 `key` 存在，则返回 `value`，如 `key` 不存在，使用 `key` 和 `func f` 的返回值 给 `map` 设置键值，然后返回该值。
+
+- 格式：
+
+```go
+GetOrSetFunc(key interface{}, f func() interface{}) interface{}
+```
+
+- 示例：
+
+```go
+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
+}
+```
+
+## `GetOrSetFuncLock`
+
+- 说明： `GetOrSetFunc` 如 `key` 存在，则返回 `value`，如 `key` 不存在，使用 `key` 和 `func f` 的返回值 给 `map` 设置键值，然后返回该值。
+
+- 注意： `GetOrSetFuncLock` 与 `GetOrSetFunc` 函数的不同之处在于它在写锁中执行函数 `f`。
+
+- 格式：
+
+```go
+GetOrSetFuncLock(key interface{}, f func() interface{}) interface{}
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `GetVar` 根据键名 `key` 查询并返回对应的键值，键值使用泛型类型 `*gvar.Var` 返回。
+
+- 格式：
+
+```go
+GetVar(key interface{}) *gvar.Var
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `GetVarOrSet` 根据键名 `key` 查询并返回对应的键值。当对应的键值不存在时，使用 `value` 设置该键值，并返回查询/设置的键值。键值使用泛型类型 `*gvar.Var` 返回。
+
+- 格式：
+
+```go
+GetVarOrSet(key interface{}, value interface{}) *gvar.Var
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `GetVarOrSetFunc` 根据键名 `key` 查询并返回对应的键值。当对应的键值不存在时，使用 `func f` 的返回值设置该键值，并返回查询/设置的键值。键值使用泛型类型 `*gvar.Var` 返回。
+
+- 格式：
+
+```go
+GetVarOrSetFunc(key interface{}, f func() interface{}) *gvar.Var
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `GetVarOrSetFuncLock` 根据键名 `key` 查询并返回对应的键值。当对应的键值不存在时，使用 `func f` 的返回值设置该键值，并返回查询/设置的键值。键值使用泛型类型 `*gvar.Var` 返回。
+
+- 注意： `GetVarOrSetFuncLock` 与 `GetVarOrSetFunc` 函数的不同之处在于它在写锁中执行函数 `f`。即当有多个 `goroutine` 同时调用该方法时，函数 `f` 将会在执行之前被阻塞。
+- 格式：
+
+```go
+GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gvar.Var
+```
+
+- 示例：
+
+```go
+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
+}
+```
+
+## `SetIfNotExist`
+
+- 说明：如果 `key` 不存在，则 `SetIfNotExist` 为 `map` 设置值键值对 `key/value`，并且返回 `true`。如果 `key` 存在，则返回 `false`，而 `value` 将被忽略。
+
+- 格式：
+
+```go
+SetIfNotExist(key interface{}, value interface{}) bool
+```
+
+- 示例：
+
+```go
+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]
+}
+```
+
+## `SetIfNotExistFunc`
+
+- 说明：如果 `key` 不存在，则 `SetIfNotExistFunc` 为 `map` 设置值为函数 `f` 的返回值，并且返回 `true`。如果 `key` 存在，则返回 `false`，并且 `value` 将被忽略。
+
+- 格式：
+
+```go
+SetIfNotExistFunc(key interface{}, f func() interface{}) bool
+```
+
+- 示例：
+
+```go
+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]
+}
+```
+
+## `SetIfNotExistFuncLock`
+
+- 说明：如果 `key` 不存在，则 `SetIfNotExistFunc` 为 `map` 设置值为 `func c` 的返回值，然后返回 `true`。如果 `key` 存在，则返回 `false`，而 `value` 将被忽略。
+
+- 注意： `SetIfNotExistFuncLock` 与 `SetIfNotExistFunc` 函数的不同之处在于它在 `mutex.Lock` 中执行函数 `f`。
+
+- 格式：
+
+```go
+SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool
+```
+
+- 示例：
+
+```go
+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]
+}
+```
+
+## `Remove`
+
+- 说明：按给定的 `key` 从 `map` 中删除 `value`，并返回此删除的 `value`。
+
+- 格式：
+
+```go
+Remove(key interface{}) (value interface{})
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Removes` 按给定的 `key` 批量删除 `map` 的 `value`。
+
+- 格式：
+
+```go
+Removes(keys []interface{})
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Keys` 将 `map` 的所有 `key` 作为 `slice` 返回。
+
+- 格式：
+
+```go
+Keys() []interface{}
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Values` 将 `map` 的所有 `value` 作为 `slice` 返回。
+
+- 格式：
+
+```go
+Values() []interface{}
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Contains` 检查 `key` 是否存在。如果 `key` 存在，则返回 `true`，否则返回 `false`。
+
+- 注意：键名类型为 `interface{}`，因此匹配判断需要保证类型和数值一致。
+- 格式：
+
+```go
+Contains(key interface{}) bool
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Size` 返回 `map` 的大小。
+
+- 格式：
+
+```go
+Size() int
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `IsEmpty` 检查 `map` 是否为空。如果 `map` 为空，则返回 `true`，否则返回 `false`。
+
+- 格式：
+
+```go
+IsEmpty() bool
+```
+
+- 示例：
+
+```go
+func ExampleAnyAnyMap_IsEmpty() {
+      var m gmap.Map
+      fmt.Println(m.IsEmpty())
+
+      m.Set("k1", "v1")
+      fmt.Println(m.IsEmpty())
+
+      // Output:
+      // true
+      // false
+}
+```
+
+## `Clear`
+
+- 说明： `Clear` 删除 `map` 的所有数据。
+
+- 格式：
+
+```go
+Clear()
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Replace` 用给定的 `data` 完整替换 `map` 的 `value`。
+
+- 格式：
+
+```go
+Replace(data map[interface{}]interface{})
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `LockFunc` 在写锁中执行函数 `f`。
+
+- 格式：
+
+```go
+LockFunc(f func(m map[interface{}]interface{}))
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `RLockFunc` 在读锁中执行函数 `f`。
+
+- 格式：
+
+```go
+RLockFunc(f func(m map[interface{}]interface{}))
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `Flip` 将 `map` 的 `key` 与 `value` 进行交换。
+
+- 格式：
+
+```go
+Flip()
+```
+
+- 示例：
+
+```go
+func ExampleAnyAnyMap_Flip() {
+      var m gmap.Map
+      m.Sets(g.MapAnyAny{
+          "k1": "v1",
+      })
+      m.Flip()
+      fmt.Println(m.Map())
+
+      // Output:
+      // map[v1:k1]
+}
+```
+
+## `Merge`
+
+- 说明： `Merge` 合并两个AnyAnyMap。入参 `map` 将合并到原 `map` 中。
+
+- 格式：
+
+```go
+Merge(other *AnyAnyMap)
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `String` 以字符串形式返回 `map`。
+
+- 格式：
+
+```go
+String() string
+```
+
+- 示例：
+
+```go
+func ExampleAnyAnyMap_String() {
+      var m gmap.Map
+      m.Sets(g.MapAnyAny{
+          "k1": "v1",
+      })
+
+      fmt.Println(m.String())
+
+      // Output:
+      // {"k1":"v1"}
+}
+```
+
+## `MarshalJSON`
+
+- 说明： `MarshalJSON` 实现 `json.Marshal` 的接口。
+
+- 格式：
+
+```go
+MarshalJSON() ([]byte, error)
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `UnmarshalJSON` 实现了 `json.Unmarshal` 的接口。
+
+- 格式：
+
+```go
+UnmarshalJSON(b []byte) error
+```
+
+- 示例：
+
+```go
+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`
+
+- 说明： `UnmarshalValue` 是一个接口实现，它通过任意类型的变量初始化当前 `map`。
+
+- 格式：
+
+```go
+UnmarshalValue(value interface{}) (err error)
+```
+
+- 示例：
+
+```go
+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]
+}
+```