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]
  }