New
NewFrom
Iterator
Clone
Map
MapCopy
MapStrAny
FilterEmpty
FilterNil
Set
Sets
Search
Get
Pop
Pops
GetOrSet
GetOrSetFunc
GetOrSetFuncLock
GetVar
GetVarOrSet
GetVarOrSetFunc
GetVarOrSetFuncLock
SetIfNotExist
SetIfNotExistFunc
SetIfNotExistFuncLock
Remove
Removes
Keys
Values
Contains
Size
IsEmpty
Clear
Replace
LockFunc
RLockFunc
Flip
Merge
String
MarshalJSON
UnmarshalJSON
UnmarshalValue

以下常用方法列表，文档更新可能滞后于代码新特性，更多的方法及示例请参考代码文档：https://pkg.go.dev/github.com/gogf/gf/v2/container/gmap

`New`

说明：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`

说明：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`

说明：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`

说明：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() 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`

说明：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

说明：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`

说明：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

说明：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

说明：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

说明：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`

说明：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`

说明：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`

说明：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

说明：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

说明：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`

说明：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
}

GetOrSetFuncLock

说明：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

说明：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`

说明：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

说明：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

说明：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
}

`SetIfNotExist`

说明：如果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]
}

SetIfNotExistFunc

说明：如果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]
}

`SetIfNotExistFuncLock`

说明：如果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]
}

Remove

说明：按给定的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

说明：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

说明：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

说明：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

说明：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`

说明：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`

说明：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

说明：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`

说明：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`

说明：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`

说明：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`

说明：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`

说明：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`

说明：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`

说明：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`

说明：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`

说明：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]
}

字典类型-方法介绍

New

NewFrom

Iterator

Clone

Map

MapCopy