map类

package
v0.0.0-...-2910145 Latest Latest
Warning

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

 Go to latest Published: Feb 14, 2024 License: MIT Imports: 11 Imported by: 0

Documentation

Overview

包gmap提供了最常用的映射容器，同时支持并发安全/非安全切换功能。

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AnyAnyMap 

type AnyAnyMap struct {
	// contains filtered or unexported fields
}

AnyAnyMap 包装了 map 类型 `map[interface{}]interface{}`，并提供了更多的映射功能。

func X创建AnyAny 

func X创建AnyAny(并发安全 ...bool) *AnyAnyMap

NewAnyAnyMap 创建并返回一个空的哈希映射。 参数 `safe` 用于指定是否使用线程安全的 map， 默认为 false。

func X创建AnyAny并从Map 

func X创建AnyAny并从Map(map值 map[interface{}]interface{}, 并发安全 ...bool) *AnyAnyMap

NewAnyAnyMapFrom 通过给定的 `data` 地图创建并返回一个哈希映射。 注意，参数 `data` 中的地图将被设置为底层数据地图（无深度复制）， 因此在外部修改该映射时可能存在一些并发安全问题。

func (*AnyAnyMap) DeepCopy 

func (m *AnyAnyMap) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (AnyAnyMap) MarshalJSON 

func (m AnyAnyMap) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。

Example 
var m map类.Map
m.X设置值Map(g.MapAnyAny{
	"k1": "v1",
	"k2": "v2",
	"k3": "v3",
	"k4": "v4",
})

bytes, err := json.Marshal(&m)
if err == nil {
	fmt.Println(转换类.String(bytes))
}

Output:

{"k1":"v1","k2":"v2","k3":"v3","k4":"v4"}

func (*AnyAnyMap) String 

func (m *AnyAnyMap) String() string

String 将映射转换为字符串并返回。

Example 
var m map类.Map
m.X设置值Map(g.MapAnyAny{
	"k1": "v1",
})

fmt.Println(m.String())

var m1 *map类.Map = nil
fmt.Println(len(m1.String()))

Output:

{"k1":"v1"}
0

func (*AnyAnyMap) UnmarshalJSON 

func (m *AnyAnyMap) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

Example 
var m map类.Map
m.X设置值Map(g.MapAnyAny{
	"k1": "v1",
	"k2": "v2",
	"k3": "v3",
	"k4": "v4",
})

var n map类.Map

err := json.Unmarshal(转换类.X取字节集(m.String()), &n)
if err == nil {
	fmt.Println(n.X取Map())
}

Output:

map[k1:v1 k2:v2 k3:v3 k4:v4]

func (*AnyAnyMap) UnmarshalValue 

func (m *AnyAnyMap) UnmarshalValue(value interface{}) (err error)

UnmarshalValue 是一个接口实现，用于为 map 设置任意类型的值。

Example 
type User struct {
	Uid   int
	Name  string
	Pass1 string `gconv:"password1"`
	Pass2 string `gconv:"password2"`
}

var (
	m    map类.AnyAnyMap
	user = User{
		Uid:   1,
		Name:  "john",
		Pass1: "123",
		Pass2: "456",
	}
)
if err := 转换类.Scan(user, &m); err == nil {
	fmt.Printf("%#v", m.X取Map())
}

Output:

map[interface {}]interface {}{"Name":"john", "Uid":1, "password1":"123", "password2":"456"}

func (*AnyAnyMap) X出栈 

func (m *AnyAnyMap) X出栈() (名称, 值 interface{})

Pop 从映射中检索并删除一个项目。

func (*AnyAnyMap) X出栈多个 

func (m *AnyAnyMap) X出栈多个(数量 int) map[interface{}]interface{}

Pops 从映射中获取并删除 `size` 个元素。 当 size == -1 时，它返回所有元素。

func (*AnyAnyMap) X删除 

func (m *AnyAnyMap) X删除(名称 interface{}) (值 interface{})

Remove通过给定的`key`从map中删除值，并返回这个被删除的值。

func (*AnyAnyMap) X删除多个值 

func (m *AnyAnyMap) X删除多个值(名称 []interface{})

删除map中通过keys指定的所有值，进行批量删除。

func (*AnyAnyMap) X删除所有nil值 

func (m *AnyAnyMap) X删除所有nil值()

FilterNil 删除所有值为nil的键值对。

func (*AnyAnyMap) X删除所有空值 

func (m *AnyAnyMap) X删除所有空值()

FilterEmpty 删除所有值为空的键值对。 以下类型的值被视为空：0, nil, false, "", 切片/映射/通道长度为0。

func (*AnyAnyMap) X取Map 

func (m *AnyAnyMap) X取Map() map[interface{}]interface{}

Map 返回底层数据映射。 注意，如果它在并发安全的使用场景下，将会返回底层数据的一个副本， 否则将返回指向底层数据的指针。

func (*AnyAnyMap) X取MapStrAny 

func (m *AnyAnyMap) X取MapStrAny() map[string]interface{}

MapStrAny 返回该映射底层数据的一个副本，类型为 map[string]interface{}。

func (*AnyAnyMap) X取值 

func (m *AnyAnyMap) X取值(名称 interface{}) (值 interface{})

Get 通过给定的 `key` 返回对应的值。

func (*AnyAnyMap) X取值或设置值 

func (m *AnyAnyMap) X取值或设置值(名称 interface{}, 值 interface{}) interface{}

GetOrSet 函数通过 key 返回对应的 value， 若该 key 不存在，则使用给定的 `value` 设置并返回这个设置后的值。

func (*AnyAnyMap) X取值或设置值_函数 

func (m *AnyAnyMap) X取值或设置值_函数(名称 interface{}, 回调函数 func() interface{}) interface{}

GetOrSetFunc 通过键返回值，如果该键不存在， 则使用回调函数 `f` 返回的值进行设置，并随后返回这个设置后的值。

func (*AnyAnyMap) X取值或设置值_函数带锁 

func (m *AnyAnyMap) X取值或设置值_函数带锁(名称 interface{}, 回调函数 func() interface{}) interface{}

GetOrSetFuncLock 通过键返回值，如果该键不存在，则使用回调函数 `f` 返回的值设置并返回这个新值。

GetOrSetFuncLock 与 GetOrSetFunc 函数的不同之处在于，它在哈希映射的 mutex.Lock 保护下执行函数 `f`。

func (*AnyAnyMap) X取值或设置值泛型类 

func (m *AnyAnyMap) X取值或设置值泛型类(名称 interface{}, 值 interface{}) *泛型类.Var

GetVarOrSet 返回一个从 GetOrSet 获取结果的 Var。 返回的 Var 不是线程安全的。

func (*AnyAnyMap) X取值或设置值泛型类_函数 

func (m *AnyAnyMap) X取值或设置值泛型类_函数(名称 interface{}, 回调函 func() interface{}) *泛型类.Var

GetVarOrSetFunc 返回一个 Var，其结果来自 GetOrSetFunc 的调用。 返回的 Var 不具备并发安全特性。

func (*AnyAnyMap) X取值或设置值泛型类_函数带锁 

func (m *AnyAnyMap) X取值或设置值泛型类_函数带锁(名称 interface{}, 回调函数 func() interface{}) *泛型类.Var

GetVarOrSetFuncLock 返回一个 Var，其结果来自 GetOrSetFuncLock。 返回的 Var 不是并发安全的。

func (*AnyAnyMap) X取值泛型类 

func (m *AnyAnyMap) X取值泛型类(名称 interface{}) *泛型类.Var

GetVar 通过给定的 `key` 返回一个具有相应值的 Var。 返回的 Var 不是线程安全的。

func (*AnyAnyMap) X取副本 

func (m *AnyAnyMap) X取副本(并发安全 ...bool) *AnyAnyMap

Clone 返回一个新的哈希映射，其中包含当前映射数据的副本。

func (*AnyAnyMap) X取所有值 

func (m *AnyAnyMap) X取所有值() []interface{}

Values 返回该映射的所有值作为一个切片。

func (*AnyAnyMap) X取所有名称 

func (m *AnyAnyMap) X取所有名称() []interface{}

Keys 返回该映射的所有键作为一个切片。

func (*AnyAnyMap) X取数量 

func (m *AnyAnyMap) X取数量() int

Size 返回映射的大小。

func (*AnyAnyMap) X合并 

func (m *AnyAnyMap) X合并(map值 *AnyAnyMap)

Merge 合并两个哈希映射。 `other` 映射将会被合并到映射 `m` 中。

func (*AnyAnyMap) X名称值交换 

func (m *AnyAnyMap) X名称值交换()

Flip 将映射中的键值对进行交换，即把键变成值，值变成键。

func (*AnyAnyMap) X是否为子集 

func (m *AnyAnyMap) X是否为子集(父集Map *AnyAnyMap) bool

IsSubOf 检查当前 map 是否为 `other` 的子集。

func (*AnyAnyMap) X是否为空 

func (m *AnyAnyMap) X是否为空() bool

IsEmpty 检查该映射是否为空。 如果映射为空，则返回 true，否则返回 false。

func (*AnyAnyMap) X是否存在 

func (m *AnyAnyMap) X是否存在(名称 interface{}) bool

Contains 检查键是否存在。 如果 `key` 存在，则返回 true，否则返回 false。

func (*AnyAnyMap) X替换 

func (m *AnyAnyMap) X替换(map值 map[interface{}]interface{})

用给定的`data`替换map中的数据。

func (*AnyAnyMap) X查找 

func (m *AnyAnyMap) X查找(名称 interface{}) (值 interface{}, 成功 bool)

Search 通过给定的 `key` 在映射中搜索。 第二个返回参数 `found` 如果找到了 key，则为 true，否则为 false。

func (*AnyAnyMap) X比较 

func (m *AnyAnyMap) X比较(map值 *AnyAnyMap) (增加的名称, 删除的名称, 更新数据的名称 []interface{})

Diff 函数用于比较当前映射 `m` 与映射 `other`，并返回它们不同的键。 返回的 `addedKeys` 是存在于映射 `m` 中但不在映射 `other` 中的键。 返回的 `removedKeys` 是存在于映射 `other` 中但不在映射 `m` 中的键。 返回的 `updatedKeys` 是同时存在于映射 `m` 和 `other` 中，但其对应值不相等（`!=`）的键。

func (*AnyAnyMap) X浅拷贝 

func (m *AnyAnyMap) X浅拷贝() map[interface{}]interface{}

MapCopy 返回哈希映射底层数据的浅复制副本。

func (*AnyAnyMap) X清空 

func (m *AnyAnyMap) X清空()

清空删除映射中的所有数据，它会重新创建一个新的底层数据映射。

func (*AnyAnyMap) X设置值 

func (m *AnyAnyMap) X设置值(名称 interface{}, 值 interface{})

Set 将键值对设置到哈希映射中。

func (*AnyAnyMap) X设置值Map 

func (m *AnyAnyMap) X设置值Map(map值 map[interface{}]interface{})

Sets批量设置键值对到哈希映射中。

func (*AnyAnyMap) X设置值并跳过已存在 

func (m *AnyAnyMap) X设置值并跳过已存在(名称 interface{}, 值 interface{}) bool

SetIfNotExist 如果`key`不存在，则将`value`设置到map中，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*AnyAnyMap) X设置值并跳过已存在_函数 

func (m *AnyAnyMap) X设置值并跳过已存在_函数(名称 interface{}, 回调函数 func() interface{}) bool

SetIfNotExistFunc 使用回调函数`f`的返回值设置键值，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*AnyAnyMap) X设置值并跳过已存在_函数带锁 

func (m *AnyAnyMap) X设置值并跳过已存在_函数带锁(名称 interface{}, 回调函数 func() interface{}) bool

SetIfNotExistFuncLock 函数用于设置键值对，其值为回调函数 `f` 的返回值，并在设置成功时返回 true。 若 `key` 已存在，则返回 false，并且将忽略 `value` 参数。

SetIfNotExistFuncLock 与 SetIfNotExistFunc 函数的区别在于， 它在执行回调函数 `f` 时会锁定哈希表的 mutex 锁。

func (*AnyAnyMap) X遍历 

func (m *AnyAnyMap) X遍历(回调函数 func(k interface{}, v interface{}) bool)

Iterator 使用自定义回调函数 `f` 以只读方式迭代哈希表。 如果 `f` 返回 true，则继续迭代；如果返回 false，则停止迭代。

func (*AnyAnyMap) X遍历写锁定 

func (m *AnyAnyMap) X遍历写锁定(回调函数 func(m map[interface{}]interface{}))

LockFunc 使用给定的回调函数 `f` 在 RWMutex.Lock 内锁定写入操作。

func (*AnyAnyMap) X遍历读锁定 

func (m *AnyAnyMap) X遍历读锁定(回调函数 func(m map[interface{}]interface{}))

RLockFunc 在 RWMutex.RLock 内使用给定的回调函数 `f` 进行读取锁定。

type HashMap 

type HashMap = AnyAnyMap // HashMap 是 AnyAnyMap 的别名。

type IntAnyMap 

type IntAnyMap struct {
	// contains filtered or unexported fields
}

IntAnyMap 实现了一个带有 RWMutex（读写互斥锁）且包含 switch 功能的 map[int]interface{} 类型。 在 Go 语言中，这段注释表示 IntAnyMap 结构体或类型定义提供了一种特殊的数据结构，它类似于标准库中的 map[int]interface{}，即键为 int 类型，值为 interface{} 类型的映射。同时，该数据结构内部集成了 sync.RWMutex 来保证在并发环境下对映射的安全读写操作，并可能通过 switch 语句来实现某些与同步控制相关的功能逻辑。

func X创建IntAny 

func X创建IntAny(并发安全 ...bool) *IntAnyMap

NewIntAnyMap 返回一个空的 IntAnyMap 对象。 参数 `safe` 用于指定是否使用线程安全的 map，其默认值为 false。

func X创建IntAny并从Map 

func X创建IntAny并从Map(map值 map[int]interface{}, 并发安全 ...bool) *IntAnyMap

NewIntAnyMapFrom 通过给定的 `data` 创建并返回一个哈希映射。 注意，参数 `data` 中的映射将被设置为底层数据映射（非深度复制）， 因此在外部修改该映射时可能会存在一些并发安全问题。

func (*IntAnyMap) DeepCopy 

func (m *IntAnyMap) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (IntAnyMap) MarshalJSON 

func (m IntAnyMap) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。

Example 
var m map类.IntAnyMap
m.X设置值Map(g.MapIntAny{
	1: "v1",
	2: "v2",
	3: "v3",
	4: "v4",
})

bytes, err := json.Marshal(&m)
if err == nil {
	fmt.Println(转换类.String(bytes))
}

Output:

{"1":"v1","2":"v2","3":"v3","4":"v4"}

func (*IntAnyMap) String 

func (m *IntAnyMap) String() string

String 将映射转换为字符串并返回。

Example 
var m map类.IntAnyMap
m.X设置值Map(g.MapIntAny{
	1: "v1",
})

fmt.Println(m.String())

var m1 *map类.IntAnyMap = nil
fmt.Println(len(m1.String()))

Output:

{"1":"v1"}
0

func (*IntAnyMap) UnmarshalJSON 

func (m *IntAnyMap) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

Example 
var m map类.IntAnyMap
m.X设置值Map(g.MapIntAny{
	1: "v1",
	2: "v2",
	3: "v3",
	4: "v4",
})

var n map类.Map

err := json.Unmarshal(转换类.X取字节集(m.String()), &n)
if err == nil {
	fmt.Println(n.X取Map())
}

Output:

map[1:v1 2:v2 3:v3 4:v4]

func (*IntAnyMap) UnmarshalValue 

func (m *IntAnyMap) UnmarshalValue(value interface{}) (err error)

UnmarshalValue 是一个接口实现，用于为 map 设置任意类型的值。

Example 
var m map类.IntAnyMap

goWeb := map[int]interface{}{
	1: "goframe",
	2: "gin",
	3: "echo",
}

if err := 转换类.Scan(goWeb, &m); err == nil {
	fmt.Printf("%#v", m.X取Map())
}

Output:

map[int]interface {}{1:"goframe", 2:"gin", 3:"echo"}

func (*IntAnyMap) X出栈 

func (m *IntAnyMap) X出栈() (名称 int, 值 interface{})

Pop 从映射中检索并删除一个项目。

func (*IntAnyMap) X出栈多个 

func (m *IntAnyMap) X出栈多个(数量 int) map[int]interface{}

Pops 从映射中获取并删除 `size` 个元素。 当 size == -1 时，它返回所有元素。

func (*IntAnyMap) X删除 

func (m *IntAnyMap) X删除(名称 int) (值 interface{})

Remove通过给定的`key`从map中删除值，并返回这个被删除的值。

func (*IntAnyMap) X删除多个值 

func (m *IntAnyMap) X删除多个值(名称 []int)

删除map中通过keys指定的所有值，进行批量删除。

func (*IntAnyMap) X删除所有nil值 

func (m *IntAnyMap) X删除所有nil值()

FilterNil 删除所有值为nil的键值对。

func (*IntAnyMap) X删除所有空值 

func (m *IntAnyMap) X删除所有空值()

FilterEmpty 删除所有值为空的键值对。 以下类型的值被视为空：0, nil, false, "", 切片/映射/通道长度为0。

func (*IntAnyMap) X取Map 

func (m *IntAnyMap) X取Map() map[int]interface{}

Map 返回底层数据映射。 注意，如果它在并发安全的使用场景下，将会返回底层数据的一个副本， 否则将返回指向底层数据的指针。

func (*IntAnyMap) X取MapStrAny 

func (m *IntAnyMap) X取MapStrAny() map[string]interface{}

MapStrAny 返回该映射底层数据的一个副本，类型为 map[string]interface{}。

func (*IntAnyMap) X取值 

func (m *IntAnyMap) X取值(名称 int) (值 interface{})

Get 通过给定的 `key` 返回对应的值。

func (*IntAnyMap) X取值或设置值 

func (m *IntAnyMap) X取值或设置值(名称 int, 值 interface{}) interface{}

GetOrSet 函数通过 key 返回对应的 value， 若该 key 不存在，则使用给定的 `value` 设置并返回这个设置后的值。

func (*IntAnyMap) X取值或设置值_函数 

func (m *IntAnyMap) X取值或设置值_函数(名称 int, 回调函数 func() interface{}) interface{}

GetOrSetFunc 通过键返回值，如果该键不存在，则使用回调函数 `f` 返回的值设置并返回这个值。

func (*IntAnyMap) X取值或设置值_函数带锁 

func (m *IntAnyMap) X取值或设置值_函数带锁(名称 int, 回调函数 func() interface{}) interface{}

GetOrSetFuncLock 通过键返回值，如果不存在，则使用回调函数 `f` 返回的值进行设置并返回这个新值。

GetOrSetFuncLock 与 GetOrSetFunc 函数的不同之处在于，它在哈希映射的 mutex.Lock 保护下执行函数 `f`。

func (*IntAnyMap) X取值或设置值泛型类 

func (m *IntAnyMap) X取值或设置值泛型类(名称 int, 值 interface{}) *泛型类.Var

GetVarOrSet 返回一个从 GetVarOrSet 获取结果的 Var。 返回的 Var 对象不保证线程安全。

func (*IntAnyMap) X取值或设置值泛型类_函数 

func (m *IntAnyMap) X取值或设置值泛型类_函数(名称 int, 回调函数 func() interface{}) *泛型类.Var

GetVarOrSetFunc 返回一个 Var，其结果来自 GetOrSetFunc 的调用。 返回的 Var 不具备并发安全特性。

func (*IntAnyMap) X取值或设置值泛型类_函数带锁 

func (m *IntAnyMap) X取值或设置值泛型类_函数带锁(名称 int, 回调函数 func() interface{}) *泛型类.Var

GetVarOrSetFuncLock 返回一个 Var，其结果来自 GetOrSetFuncLock。 返回的 Var 不是并发安全的。

func (*IntAnyMap) X取值泛型类 

func (m *IntAnyMap) X取值泛型类(名称 int) *泛型类.Var

GetVar 通过给定的 `key` 返回一个具有相应值的 Var。 返回的 Var 不是线程安全的。

func (*IntAnyMap) X取副本 

func (m *IntAnyMap) X取副本() *IntAnyMap

Clone 返回一个新的哈希映射，其中包含当前映射数据的副本。

func (*IntAnyMap) X取所有值 

func (m *IntAnyMap) X取所有值() []interface{}

Values 返回该映射的所有值作为一个切片。

func (*IntAnyMap) X取所有名称 

func (m *IntAnyMap) X取所有名称() []int

Keys 返回该映射的所有键作为一个切片。

func (*IntAnyMap) X取数量 

func (m *IntAnyMap) X取数量() int

Size 返回映射的大小。

func (*IntAnyMap) X合并 

func (m *IntAnyMap) X合并(map值 *IntAnyMap)

Merge 合并两个哈希映射。 `other` 映射将会被合并到映射 `m` 中。

func (*IntAnyMap) X名称值交换 

func (m *IntAnyMap) X名称值交换()

Flip 将映射中的键值对进行交换，即把键变成值，值变成键。

func (*IntAnyMap) X是否为子集 

func (m *IntAnyMap) X是否为子集(父集Map *IntAnyMap) bool

IsSubOf 检查当前 map 是否为 `other` 的子集。

func (*IntAnyMap) X是否为空 

func (m *IntAnyMap) X是否为空() bool

IsEmpty 检查该映射是否为空。 如果映射为空，则返回 true，否则返回 false。

func (*IntAnyMap) X是否存在 

func (m *IntAnyMap) X是否存在(名称 int) bool

Contains 检查键是否存在。 如果 `key` 存在，则返回 true，否则返回 false。

func (*IntAnyMap) X替换 

func (m *IntAnyMap) X替换(map值 map[int]interface{})

用给定的`data`替换map中的数据。

func (*IntAnyMap) X查找 

func (m *IntAnyMap) X查找(名称 int) (值 interface{}, 成功 bool)

Search 通过给定的 `key` 在映射中搜索。 第二个返回参数 `found` 如果找到了 key，则为 true，否则为 false。

func (*IntAnyMap) X比较 

func (m *IntAnyMap) X比较(map值 *IntAnyMap) (增加的名称, 删除的名称, 更新数据的名称 []int)

Diff 函数用于比较当前映射 `m` 与映射 `other`，并返回它们不同的键。 返回的 `addedKeys` 是存在于映射 `m` 中但不在映射 `other` 中的键。 返回的 `removedKeys` 是存在于映射 `other` 中但不在映射 `m` 中的键。 返回的 `updatedKeys` 是同时存在于映射 `m` 和 `other` 中，但其对应值不相等（`!=`）的键。

func (*IntAnyMap) X浅拷贝 

func (m *IntAnyMap) X浅拷贝() map[int]interface{}

MapCopy 返回哈希映射底层数据的一个副本。

func (*IntAnyMap) X清空 

func (m *IntAnyMap) X清空()

清空删除映射中的所有数据，它会重新创建一个新的底层数据映射。

func (*IntAnyMap) X设置值 

func (m *IntAnyMap) X设置值(名称 int, 值 interface{})

Set 将键值对设置到哈希映射中。

func (*IntAnyMap) X设置值Map 

func (m *IntAnyMap) X设置值Map(map值 map[int]interface{})

Sets批量设置键值对到哈希映射中。

func (*IntAnyMap) X设置值并跳过已存在 

func (m *IntAnyMap) X设置值并跳过已存在(名称 int, 值 interface{}) bool

SetIfNotExist 如果`key`不存在，则将`value`设置到map中，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*IntAnyMap) X设置值并跳过已存在_函数 

func (m *IntAnyMap) X设置值并跳过已存在_函数(名称 int, 回调函数 func() interface{}) bool

SetIfNotExistFunc 使用回调函数`f`的返回值设置键值，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*IntAnyMap) X设置值并跳过已存在_函数带锁 

func (m *IntAnyMap) X设置值并跳过已存在_函数带锁(名称 int, 回调函数 func() interface{}) bool

SetIfNotExistFuncLock 函数用于设置键值对，其值为回调函数 `f` 的返回值，并在设置成功时返回 true。 若 `key` 已存在，则返回 false，并且将忽略 `value` 参数。

SetIfNotExistFuncLock 与 SetIfNotExistFunc 函数的区别在于， 它在执行回调函数 `f` 时会锁定哈希表的 mutex 锁。

func (*IntAnyMap) X遍历 

func (m *IntAnyMap) X遍历(回调函数 func(k int, v interface{}) bool)

Iterator 使用自定义回调函数 `f` 以只读方式迭代哈希表。 如果 `f` 返回 true，则继续迭代；如果返回 false，则停止迭代。

func (*IntAnyMap) X遍历写锁定 

func (m *IntAnyMap) X遍历写锁定(回调函数 func(m map[int]interface{}))

LockFunc 使用给定的回调函数 `f` 在 RWMutex.Lock 内锁定写入操作。

func (*IntAnyMap) X遍历读锁定 

func (m *IntAnyMap) X遍历读锁定(回调函数 func(m map[int]interface{}))

RLockFunc 在 RWMutex.RLock 内使用给定的回调函数 `f` 进行读取锁定。

type IntIntMap 

type IntIntMap struct {
	// contains filtered or unexported fields
}

IntIntMap 实现了一个带有 RWMutex（读写互斥锁）且具有 switch 功能的 map[int]int 类型。 （注：这里的“switch”可能是指在对映射进行操作时，根据操作类型（如读、写）进行相应控制。）

func X创建IntInt 

func X创建IntInt(并发安全 ...bool) *IntIntMap

NewIntIntMap 返回一个空的 IntIntMap 对象。 参数 `safe` 用于指定是否在并发安全的情况下使用 map，其默认值为 false。

func X创建IntInt并从Map 

func X创建IntInt并从Map(map值 map[int]int, 并发安全 ...bool) *IntIntMap

NewIntIntMapFrom 创建并返回一个由给定的 `data` 地图生成的哈希映射。 注意，参数 `data` 地图将会被直接设置为底层数据地图（非深度复制）， 因此在外部修改该映射时可能会存在并发安全问题。 ```go 新建一个整数到整数的哈希映射，其来源是给定的 `data` 映射。 需要注意的是，函数将参数 `data` 映射原样设置为底层的数据映射（并非进行深拷贝处理）， 因此，在外部对这个映射进行修改时，可能会引发并发访问安全问题。

func (*IntIntMap) DeepCopy 

func (m *IntIntMap) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (IntIntMap) MarshalJSON 

func (m IntIntMap) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。

Example 
var m map类.IntIntMap
m.X设置值Map(g.MapIntInt{
	1: 1,
	2: 2,
	3: 3,
	4: 4,
})

bytes, err := json.Marshal(&m)
if err == nil {
	fmt.Println(转换类.String(bytes))
}

Output:

{"1":1,"2":2,"3":3,"4":4}

func (*IntIntMap) String 

func (m *IntIntMap) String() string

String 将映射转换为字符串并返回。

Example 
var m map类.IntIntMap
m.X设置值Map(g.MapIntInt{
	1: 1,
})

fmt.Println(m.String())

var m1 *map类.IntIntMap = nil
fmt.Println(len(m1.String()))

Output:

{"1":1}
0

func (*IntIntMap) UnmarshalJSON 

func (m *IntIntMap) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

Example 
var m map类.IntIntMap
m.X设置值Map(g.MapIntInt{
	1: 1,
	2: 2,
	3: 3,
	4: 4,
})

var n map类.Map

err := json.Unmarshal(转换类.X取字节集(m.String()), &n)
if err == nil {
	fmt.Println(n.X取Map())
}

Output:

map[1:1 2:2 3:3 4:4]

func (*IntIntMap) UnmarshalValue 

func (m *IntIntMap) UnmarshalValue(value interface{}) (err error)

UnmarshalValue 是一个接口实现，用于为 map 设置任意类型的值。

Example 
var m map类.IntIntMap

n := map[int]int{
	1: 1001,
	2: 1002,
	3: 1003,
}

if err := 转换类.Scan(n, &m); err == nil {
	fmt.Printf("%#v", m.X取Map())
}

Output:

map[int]int{1:1001, 2:1002, 3:1003}

func (*IntIntMap) X出栈 

func (m *IntIntMap) X出栈() (名称, 值 int)

Pop 从映射中检索并删除一个项目。

func (*IntIntMap) X出栈多个 

func (m *IntIntMap) X出栈多个(数量 int) map[int]int

Pops 从映射中获取并删除 `size` 个元素。 当 size == -1 时，它返回所有元素。

func (*IntIntMap) X删除 

func (m *IntIntMap) X删除(名称 int) (值 int)

Remove通过给定的`key`从map中删除值，并返回这个被删除的值。

func (*IntIntMap) X删除多个值 

func (m *IntIntMap) X删除多个值(名称 []int)

删除map中通过keys指定的所有值，进行批量删除。

func (*IntIntMap) X删除所有空值 

func (m *IntIntMap) X删除所有空值()

FilterEmpty 删除所有值为空的键值对。 以下类型的值被视为空：0, nil, false, "", 切片/映射/通道长度为0。

func (*IntIntMap) X取Map 

func (m *IntIntMap) X取Map() map[int]int

Map 返回底层数据映射。 注意，如果它在并发安全的使用场景下，将会返回底层数据的一个副本， 否则将返回指向底层数据的指针。

func (*IntIntMap) X取MapStrAny 

func (m *IntIntMap) X取MapStrAny() map[string]interface{}

MapStrAny 返回该映射底层数据的一个副本，类型为 map[string]interface{}。

func (*IntIntMap) X取值 

func (m *IntIntMap) X取值(名称 int) (值 int)

Get 通过给定的 `key` 返回对应的值。

func (*IntIntMap) X取值或设置值 

func (m *IntIntMap) X取值或设置值(名称 int, 值 int) int

GetOrSet 函数通过 key 返回对应的 value， 若该 key 不存在，则使用给定的 `value` 设置并返回这个设置后的值。

func (*IntIntMap) X取值或设置值_函数 

func (m *IntIntMap) X取值或设置值_函数(名称 int, 回调函数 func() int) int

GetOrSetFunc 通过键返回值，如果该键不存在，则使用回调函数 `f` 返回的值设置并返回这个值。

func (*IntIntMap) X取值或设置值_函数带锁 

func (m *IntIntMap) X取值或设置值_函数带锁(名称 int, 回调函数 func() int) int

GetOrSetFuncLock 通过键返回值，如果不存在，则使用回调函数 `f` 返回的值进行设置并返回这个新值。

GetOrSetFuncLock 与 GetOrSetFunc 函数的不同之处在于，它在哈希映射的 mutex.Lock 保护下执行函数 `f`。

func (*IntIntMap) X取副本 

func (m *IntIntMap) X取副本() *IntIntMap

Clone 返回一个新的哈希映射，其中包含当前映射数据的副本。

func (*IntIntMap) X取所有值 

func (m *IntIntMap) X取所有值() []int

Values 返回该映射的所有值作为一个切片。

func (*IntIntMap) X取所有名称 

func (m *IntIntMap) X取所有名称() []int

Keys 返回该映射的所有键作为一个切片。

func (*IntIntMap) X取数量 

func (m *IntIntMap) X取数量() int

Size 返回映射的大小。

func (*IntIntMap) X合并 

func (m *IntIntMap) X合并(map值 *IntIntMap)

Merge 合并两个哈希映射。 `other` 映射将会被合并到映射 `m` 中。

func (*IntIntMap) X名称值交换 

func (m *IntIntMap) X名称值交换()

Flip 将映射中的键值对进行交换，即把键变成值，值变成键。

func (*IntIntMap) X是否为子集 

func (m *IntIntMap) X是否为子集(父集Map *IntIntMap) bool

IsSubOf 检查当前 map 是否为 `other` 的子集。

func (*IntIntMap) X是否为空 

func (m *IntIntMap) X是否为空() bool

IsEmpty 检查该映射是否为空。 如果映射为空，则返回 true，否则返回 false。

func (*IntIntMap) X是否存在 

func (m *IntIntMap) X是否存在(名称 int) bool

Contains 检查键是否存在。 如果 `key` 存在，则返回 true，否则返回 false。

func (*IntIntMap) X替换 

func (m *IntIntMap) X替换(map值 map[int]int)

用给定的`data`替换map中的数据。

func (*IntIntMap) X查找 

func (m *IntIntMap) X查找(名称 int) (值 int, 成功 bool)

Search 通过给定的 `key` 在映射中搜索。 第二个返回参数 `found` 如果找到了 key，则为 true，否则为 false。

func (*IntIntMap) X比较 

func (m *IntIntMap) X比较(map值 *IntIntMap) (增加的名称, 删除的名称, 更新数据的名称 []int)

Diff 函数用于比较当前映射 `m` 与映射 `other`，并返回它们不同的键。 返回的 `addedKeys` 是存在于映射 `m` 中但不在映射 `other` 中的键。 返回的 `removedKeys` 是存在于映射 `other` 中但不在映射 `m` 中的键。 返回的 `updatedKeys` 是同时存在于映射 `m` 和 `other` 中，但其对应值不相等（`!=`）的键。

func (*IntIntMap) X浅拷贝 

func (m *IntIntMap) X浅拷贝() map[int]int

MapCopy 返回哈希映射底层数据的一个副本。

func (*IntIntMap) X清空 

func (m *IntIntMap) X清空()

清空删除映射中的所有数据，它会重新创建一个新的底层数据映射。

func (*IntIntMap) X设置值 

func (m *IntIntMap) X设置值(名称 int, 值 int)

Set 将键值对设置到哈希映射中。

func (*IntIntMap) X设置值Map 

func (m *IntIntMap) X设置值Map(map值 map[int]int)

Sets批量设置键值对到哈希映射中。

func (*IntIntMap) X设置值并跳过已存在 

func (m *IntIntMap) X设置值并跳过已存在(名称 int, 值 int) bool

SetIfNotExist 如果`key`不存在，则将`value`设置到map中，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*IntIntMap) X设置值并跳过已存在_函数 

func (m *IntIntMap) X设置值并跳过已存在_函数(名称 int, 回调函数 func() int) bool

SetIfNotExistFunc 使用回调函数`f`的返回值设置键值，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*IntIntMap) X设置值并跳过已存在_函数带锁 

func (m *IntIntMap) X设置值并跳过已存在_函数带锁(名称 int, 回调函数 func() int) bool

SetIfNotExistFuncLock 函数用于设置键值对，其值为回调函数 `f` 的返回值，并在设置成功时返回 true。 若 `key` 已存在，则返回 false，并且将忽略 `value` 参数。

SetIfNotExistFuncLock 与 SetIfNotExistFunc 函数的区别在于， 它在执行回调函数 `f` 时会锁定哈希表的 mutex 锁。

func (*IntIntMap) X遍历 

func (m *IntIntMap) X遍历(回调函数 func(k int, v int) bool)

Iterator 使用自定义回调函数 `f` 以只读方式迭代哈希表。 如果 `f` 返回 true，则继续迭代；如果返回 false，则停止迭代。

func (*IntIntMap) X遍历写锁定 

func (m *IntIntMap) X遍历写锁定(回调函数 func(m map[int]int))

LockFunc 使用给定的回调函数 `f` 在 RWMutex.Lock 内锁定写入操作。

func (*IntIntMap) X遍历读锁定 

func (m *IntIntMap) X遍历读锁定(回调函数 func(m map[int]int))

RLockFunc 在 RWMutex.RLock 内使用给定的回调函数 `f` 进行读取锁定。

type IntStrMap 

type IntStrMap struct {
	// contains filtered or unexported fields
}

IntStrMap 实现了一个带有 RWMutex（读写互斥锁）且具有 switch 功能的 map[int]string 类型。

func X创建IntStr 

func X创建IntStr(并发安全 ...bool) *IntStrMap

NewIntStrMap 返回一个空的 IntStrMap 对象。 参数 `safe` 用于指定是否使用并发安全的 map，其默认值为 false。

func X创建IntStr并从Map 

func X创建IntStr并从Map(map值 map[int]string, 并发安全 ...bool) *IntStrMap

NewIntStrMapFrom 创建并返回一个从给定映射 `data` 转换而来的哈希映射。 注意，参数 `data` 中的映射将直接设置为底层数据映射（非深度复制）， 因此在外部对映射进行修改时可能会存在并发安全问题。

func (*IntStrMap) DeepCopy 

func (m *IntStrMap) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (IntStrMap) MarshalJSON 

func (m IntStrMap) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。

func (*IntStrMap) String 

func (m *IntStrMap) String() string

String 将映射转换为字符串并返回。

func (*IntStrMap) UnmarshalJSON 

func (m *IntStrMap) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

func (*IntStrMap) UnmarshalValue 

func (m *IntStrMap) UnmarshalValue(value interface{}) (err error)

UnmarshalValue 是一个接口实现，用于为 map 设置任意类型的值。

func (*IntStrMap) X出栈 

func (m *IntStrMap) X出栈() (名称 int, 值 string)

Pop 从映射中检索并删除一个项目。

func (*IntStrMap) X出栈多个 

func (m *IntStrMap) X出栈多个(数量 int) map[int]string

Pops 从映射中获取并删除 `size` 个元素。 当 size == -1 时，它返回所有元素。

func (*IntStrMap) X删除 

func (m *IntStrMap) X删除(名称 int) (值 string)

Remove通过给定的`key`从map中删除值，并返回这个被删除的值。

func (*IntStrMap) X删除多个值 

func (m *IntStrMap) X删除多个值(名称 []int)

删除map中通过keys指定的所有值，进行批量删除。

func (*IntStrMap) X删除所有空值 

func (m *IntStrMap) X删除所有空值()

FilterEmpty 删除所有值为空的键值对。 以下类型的值被视为空：0, nil, false, "", 切片/映射/通道长度为0。

func (*IntStrMap) X取Map 

func (m *IntStrMap) X取Map() map[int]string

Map 返回底层数据映射。 注意，如果它在并发安全的使用场景下，将会返回底层数据的一个副本， 否则将返回指向底层数据的指针。

func (*IntStrMap) X取MapStrAny 

func (m *IntStrMap) X取MapStrAny() map[string]interface{}

MapStrAny 返回该映射底层数据的一个副本，类型为 map[string]interface{}。

func (*IntStrMap) X取值 

func (m *IntStrMap) X取值(名称 int) (值 string)

Get 通过给定的 `key` 返回对应的值。

func (*IntStrMap) X取值或设置值 

func (m *IntStrMap) X取值或设置值(名称 int, 值 string) string

GetOrSet 函数通过 key 返回对应的 value， 若该 key 不存在，则使用给定的 `value` 设置并返回这个设置后的值。

func (*IntStrMap) X取值或设置值_函数 

func (m *IntStrMap) X取值或设置值_函数(名称 int, 回调函数 func() string) string

GetOrSetFunc 通过键返回值，如果该键不存在，则使用回调函数 `f` 返回的值设置并返回这个值。

func (*IntStrMap) X取值或设置值_函数带锁 

func (m *IntStrMap) X取值或设置值_函数带锁(名称 int, 回调函数 func() string) string

GetOrSetFuncLock 通过键返回值，如果不存在，则使用回调函数 `f` 返回的值进行设置并返回这个新值。

GetOrSetFuncLock 与 GetOrSetFunc 函数的不同之处在于，它在哈希映射的 mutex.Lock 保护下执行函数 `f`。

func (*IntStrMap) X取副本 

func (m *IntStrMap) X取副本() *IntStrMap

Clone 返回一个新的哈希映射，其中包含当前映射数据的副本。

func (*IntStrMap) X取所有值 

func (m *IntStrMap) X取所有值() []string

Values 返回该映射的所有值作为一个切片。

func (*IntStrMap) X取所有名称 

func (m *IntStrMap) X取所有名称() []int

Keys 返回该映射的所有键作为一个切片。

func (*IntStrMap) X取数量 

func (m *IntStrMap) X取数量() int

Size 返回映射的大小。

func (*IntStrMap) X合并 

func (m *IntStrMap) X合并(map值 *IntStrMap)

Merge 合并两个哈希映射。 `other` 映射将会被合并到映射 `m` 中。

func (*IntStrMap) X名称值交换 

func (m *IntStrMap) X名称值交换()

Flip 将映射中的键值对进行交换，即把键变成值，值变成键。

func (*IntStrMap) X是否为子集 

func (m *IntStrMap) X是否为子集(父集Map *IntStrMap) bool

IsSubOf 检查当前 map 是否为 `other` 的子集。

func (*IntStrMap) X是否为空 

func (m *IntStrMap) X是否为空() bool

IsEmpty 检查该映射是否为空。 如果映射为空，则返回 true，否则返回 false。

func (*IntStrMap) X是否存在 

func (m *IntStrMap) X是否存在(名称 int) bool

Contains 检查键是否存在。 如果 `key` 存在，则返回 true，否则返回 false。

func (*IntStrMap) X替换 

func (m *IntStrMap) X替换(map值 map[int]string)

用给定的`data`替换map中的数据。

func (*IntStrMap) X查找 

func (m *IntStrMap) X查找(名称 int) (值 string, 成功 bool)

Search 通过给定的 `key` 在映射中搜索。 第二个返回参数 `found` 如果找到了 key，则为 true，否则为 false。

func (*IntStrMap) X比较 

func (m *IntStrMap) X比较(map值 *IntStrMap) (增加的名称, 删除的名称, 更新数据的名称 []int)

Diff 函数用于比较当前映射 `m` 与映射 `other`，并返回它们不同的键。 返回的 `addedKeys` 是存在于映射 `m` 中但不在映射 `other` 中的键。 返回的 `removedKeys` 是存在于映射 `other` 中但不在映射 `m` 中的键。 返回的 `updatedKeys` 是同时存在于映射 `m` 和 `other` 中，但其对应值不相等（`!=`）的键。

func (*IntStrMap) X浅拷贝 

func (m *IntStrMap) X浅拷贝() map[int]string

MapCopy 返回哈希映射底层数据的一个副本。

func (*IntStrMap) X清空 

func (m *IntStrMap) X清空()

清空删除映射中的所有数据，它会重新创建一个新的底层数据映射。

func (*IntStrMap) X设置值 

func (m *IntStrMap) X设置值(名称 int, 值 string)

Set 将键值对设置到哈希映射中。

func (*IntStrMap) X设置值Map 

func (m *IntStrMap) X设置值Map(map值 map[int]string)

Sets批量设置键值对到哈希映射中。

func (*IntStrMap) X设置值并跳过已存在 

func (m *IntStrMap) X设置值并跳过已存在(名称 int, 值 string) bool

SetIfNotExist 如果`key`不存在，则将`value`设置到map中，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*IntStrMap) X设置值并跳过已存在_函数 

func (m *IntStrMap) X设置值并跳过已存在_函数(名称 int, 回调函数 func() string) bool

SetIfNotExistFunc 使用回调函数`f`的返回值设置键值，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*IntStrMap) X设置值并跳过已存在_函数带锁 

func (m *IntStrMap) X设置值并跳过已存在_函数带锁(名称 int, 回调函数 func() string) bool

SetIfNotExistFuncLock 函数用于设置键值对，其值为回调函数 `f` 的返回值，并在设置成功时返回 true。 若 `key` 已存在，则返回 false，并且将忽略 `value` 参数。

SetIfNotExistFuncLock 与 SetIfNotExistFunc 函数的区别在于， 它在执行回调函数 `f` 时会锁定哈希表的 mutex 锁。

func (*IntStrMap) X遍历 

func (m *IntStrMap) X遍历(回调函数 func(k int, v string) bool)

Iterator 使用自定义回调函数 `f` 以只读方式迭代哈希表。 如果 `f` 返回 true，则继续迭代；如果返回 false，则停止迭代。

func (*IntStrMap) X遍历写锁定 

func (m *IntStrMap) X遍历写锁定(回调函数 func(m map[int]string))

LockFunc 使用给定的回调函数 `f` 在 RWMutex.Lock 内锁定写入操作。

func (*IntStrMap) X遍历读锁定 

func (m *IntStrMap) X遍历读锁定(回调函数 func(m map[int]string))

RLockFunc 在 RWMutex.RLock 内使用给定的回调函数 `f` 进行读取锁定。

type ListMap 

type ListMap struct {
	// contains filtered or unexported fields
}

ListMap 是一个保留插入顺序的映射。

它底层通过哈希表存储值，并通过双向链表来保存元素的顺序。

该结构不保证线程安全。

参考文献：http://en.wikipedia.org/wiki/关联数组

func X创建链表Map并从Map 

func X创建链表Map并从Map(map值 map[interface{}]interface{}, 并发安全 ...bool) *ListMap

NewListMapFrom 从给定的 `data` map 中创建一个链接映射。 注意，参数 `data` 中的映射将被设置为底层数据映射（非深度复制）， 因此在外部修改该映射时可能会存在一些并发安全问题。

func X创建链表mp 

func X创建链表mp(并发安全 ...bool) *ListMap

NewListMap 返回一个空的链式映射。 ListMap 由哈希表（用于存储值）和双向链表（用于存储顺序）作为底层支持。 参数 `safe` 用于指定是否在并发环境中安全地使用映射，默认情况下为 false。 以下是更详细的翻译： ```go NewListMap 函数用于创建并返回一个新的、空的链式映射结构体实例。 这个 ListMap 结构体内部结合了哈希表和双向链表两种数据结构： 哈希表用于高效地存储和查找键值对，而双向链表则用于记录键值对的插入顺序。

参数 `safe` 表示是否需要保证该链式映射在并发环境中的安全性（即线程安全）， 如果设置为 true，则在多 goroutine 并发访问时会进行相应的同步控制； 若不特别指定，其默认值为 false，此时不提供并发安全保证。

func (*ListMap) DeepCopy 

func (m *ListMap) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (ListMap) MarshalJSON 

func (m ListMap) MarshalJSON() (jsonBytes []byte, err error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。

Example 
var m map类.ListMap
m.X设置值("k1", "v1")
m.X设置值("k2", "v2")
m.X设置值("k3", "v3")
m.X设置值("k4", "v4")

bytes, err := json.Marshal(&m)
if err == nil {
	fmt.Println(转换类.String(bytes))
}

Output:

{"k1":"v1","k2":"v2","k3":"v3","k4":"v4"}

func (*ListMap) String 

func (m *ListMap) String() string

String 将映射转换为字符串并返回。

Example 
var m map类.ListMap
m.X设置值Map(g.MapAnyAny{
	"k1": "v1",
})

fmt.Println(m.String())

Output:

{"k1":"v1"}

func (*ListMap) UnmarshalJSON 

func (m *ListMap) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

Example 
var m map类.ListMap
m.X设置值Map(g.MapAnyAny{
	"k1": "v1",
	"k2": "v2",
	"k3": "v3",
	"k4": "v4",
})

var n map类.ListMap

err := json.Unmarshal(转换类.X取字节集(m.String()), &n)
if err == nil {
	fmt.Println(n.X取Map())
}

Output:

map[k1:v1 k2:v2 k3:v3 k4:v4]

func (*ListMap) UnmarshalValue 

func (m *ListMap) UnmarshalValue(value interface{}) (err error)

UnmarshalValue 是一个接口实现，用于为 map 设置任意类型的值。

Example 
type User struct {
	Uid   int
	Name  string
	Pass1 string `gconv:"password1"`
	Pass2 string `gconv:"password2"`
}

var (
	m    map类.AnyAnyMap
	user = User{
		Uid:   1,
		Name:  "john",
		Pass1: "123",
		Pass2: "456",
	}
)
if err := 转换类.Scan(user, &m); err == nil {
	fmt.Printf("%#v", m.X取Map())
}

Output:

map[interface {}]interface {}{"Name":"john", "Uid":1, "password1":"123", "password2":"456"}

func (*ListMap) X出栈 

func (m *ListMap) X出栈() (名称, 值 interface{})

Pop 从映射中检索并删除一个项目。

func (*ListMap) X出栈多个 

func (m *ListMap) X出栈多个(数量 int) map[interface{}]interface{}

Pops 从映射中获取并删除 `size` 个元素。 当 size == -1 时，它返回所有元素。

func (*ListMap) X删除 

func (m *ListMap) X删除(名称 interface{}) (值 interface{})

Remove通过给定的`key`从map中删除值，并返回这个被删除的值。

func (*ListMap) X删除多个值 

func (m *ListMap) X删除多个值(名称 []interface{})

删除map中通过keys指定的所有值，进行批量删除。

func (*ListMap) X删除所有空值 

func (m *ListMap) X删除所有空值()

FilterEmpty 删除所有值为空的键值对。

func (*ListMap) X取Map 

func (m *ListMap) X取Map() map[interface{}]interface{}

Map 返回映射底层数据的一个副本。

func (*ListMap) X取MapStrAny 

func (m *ListMap) X取MapStrAny() map[string]interface{}

MapStrAny 返回该映射底层数据的一个副本，类型为 map[string]interface{}。

func (*ListMap) X取值 

func (m *ListMap) X取值(名称 interface{}) (值 interface{})

Get 通过给定的 `key` 返回对应的值。

func (*ListMap) X取值或设置值 

func (m *ListMap) X取值或设置值(名称 interface{}, 值 interface{}) interface{}

GetOrSet 函数通过 key 返回对应的 value， 若该 key 不存在，则使用给定的 `value` 设置并返回这个设置后的值。

func (*ListMap) X取值或设置值_函数 

func (m *ListMap) X取值或设置值_函数(名称 interface{}, 回调函数 func() interface{}) interface{}

GetOrSetFunc 通过键返回值，如果该键不存在， 则使用回调函数 `f` 返回的值进行设置，并随后返回这个设置后的值。

func (*ListMap) X取值或设置值_函数带锁 

func (m *ListMap) X取值或设置值_函数带锁(名称 interface{}, 回调函数 func() interface{}) interface{}

GetOrSetFuncLock 通过键返回值，如果不存在该键，则使用回调函数`f`返回的值设置该值， 并随后返回这个新设置的值。

GetOrSetFuncLock 与 GetOrSetFunc 函数的不同之处在于， 它在对 map 进行 mutex.Lock 锁定后执行函数 `f`。 这段代码注释翻译成中文后的意思是： ```markdown GetOrSetFuncLock 方法通过给定的键获取值， 若键对应的值不存在，则会使用回调函数 `f` 返回的值进行设置， 并最终返回这个已设置的值。

GetOrSetFuncLock 方法与 GetOrSetFunc 方法的区别在于， 在对映射（map）执行操作前，它会先调用 mutex.Lock 进行锁定。

func (*ListMap) X取值或设置值泛型类 

func (m *ListMap) X取值或设置值泛型类(名称 interface{}, 值 interface{}) *泛型类.Var

GetVarOrSet 返回一个从 GetVarOrSet 获取结果的 Var。 返回的 Var 对象不保证线程安全。

func (*ListMap) X取值或设置值泛型类_函数 

func (m *ListMap) X取值或设置值泛型类_函数(名称 interface{}, 回调函 func() interface{}) *泛型类.Var

GetVarOrSetFunc 返回一个 Var，其结果来自 GetOrSetFunc 的调用。 返回的 Var 不具备并发安全特性。

func (*ListMap) X取值或设置值泛型类_函数带锁 

func (m *ListMap) X取值或设置值泛型类_函数带锁(名称 interface{}, 回调函数 func() interface{}) *泛型类.Var

GetVarOrSetFuncLock 返回一个 Var，其结果来自 GetOrSetFuncLock。 返回的 Var 不是并发安全的。

func (*ListMap) X取值泛型类 

func (m *ListMap) X取值泛型类(名称 interface{}) *泛型类.Var

GetVar 通过给定的 `key` 返回一个具有相应值的 Var。 返回的 Var 不是线程安全的。

func (*ListMap) X取副本 

func (m *ListMap) X取副本(并发安全 ...bool) *ListMap

Clone 返回一个新的链接映射，其中包含当前映射数据的副本。

func (*ListMap) X取所有值 

func (m *ListMap) X取所有值() []interface{}

Values 返回该映射的所有值作为一个切片。

func (*ListMap) X取所有名称 

func (m *ListMap) X取所有名称() []interface{}

Keys 返回映射的所有键，以升序排列的切片形式。

func (*ListMap) X取数量 

func (m *ListMap) X取数量() (数量 int)

Size 返回映射的大小。

func (*ListMap) X合并 

func (m *ListMap) X合并(map值 *ListMap)

Merge 合并两个链表映射。 `other` 映射将会被合并到映射 `m` 中。

func (*ListMap) X名称值交换 

func (m *ListMap) X名称值交换()

Flip 将映射中的键值对进行交换，即把键变成值，值变成键。

func (*ListMap) X是否为空 

func (m *ListMap) X是否为空() bool

IsEmpty 检查该映射是否为空。 如果映射为空，则返回 true，否则返回 false。

func (*ListMap) X是否存在 

func (m *ListMap) X是否存在(名称 interface{}) (ok bool)

Contains 检查键是否存在。 如果 `key` 存在，则返回 true，否则返回 false。

func (*ListMap) X替换 

func (m *ListMap) X替换(map值 map[interface{}]interface{})

用给定的`data`替换map中的数据。

func (*ListMap) X查找 

func (m *ListMap) X查找(名称 interface{}) (值 interface{}, 成功 bool)

Search 通过给定的 `key` 在映射中搜索。 第二个返回参数 `found` 如果找到了 key，则为 true，否则为 false。

func (*ListMap) X清空 

func (m *ListMap) X清空()

清空删除映射中的所有数据，它会重新创建一个新的底层数据映射。

func (*ListMap) X设置值 

func (m *ListMap) X设置值(名称 interface{}, 值 interface{})

Set 将键值对设置到映射中。

func (*ListMap) X设置值Map 

func (m *ListMap) X设置值Map(map值 map[interface{}]interface{})

设置批量数据：将键值对设置到映射（map）中。

func (*ListMap) X设置值并跳过已存在 

func (m *ListMap) X设置值并跳过已存在(名称 interface{}, 值 interface{}) bool

SetIfNotExist 如果`key`不存在，则将`value`设置到map中，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*ListMap) X设置值并跳过已存在_函数 

func (m *ListMap) X设置值并跳过已存在_函数(名称 interface{}, 回调函数 func() interface{}) bool

SetIfNotExistFunc 使用回调函数`f`的返回值设置键值，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*ListMap) X设置值并跳过已存在_函数带锁 

func (m *ListMap) X设置值并跳过已存在_函数带锁(名称 interface{}, 回调函数 func() interface{}) bool

SetIfNotExistFuncLock 函数设置键值对，其值为回调函数 `f` 的返回值，并在设置成功时返回 true。 若 `key` 已存在，则返回 false，同时将忽略 `value`。

SetIfNotExistFuncLock 与 SetIfNotExistFunc 函数的区别在于， 它在操作 map 时使用了 mutex.Lock 进行加锁，确保在执行函数 `f` 期间数据同步安全。

func (*ListMap) X遍历 

func (m *ListMap) X遍历(回调函数 func(名称, 值 interface{}) bool)

Iterator 是 IteratorAsc 的别名。

func (*ListMap) X遍历升序 

func (m *ListMap) X遍历升序(回调函数 func(名称 interface{}, 值 interface{}) bool)

IteratorAsc 以升序遍历给定回调函数 `f` 的只读映射。 如果 `f` 返回 true，则继续迭代；若返回 false，则停止遍历。

func (*ListMap) X遍历降序 

func (m *ListMap) X遍历降序(回调函数 func(名称 interface{}, 值 interface{}) bool)

IteratorDesc 以降序方式遍历给定的只读映射，并使用回调函数 `f` 进行处理。 如果 `f` 返回 true，则继续迭代；若返回 false，则停止迭代。

type Map 

type Map = AnyAnyMap // Map 是 AnyAnyMap 的别名。

func NewHashMapFrom别名 

func NewHashMapFrom别名(map值 map[interface{}]interface{}, 并发安全 ...bool) *Map

NewHashMapFrom 通过给定的 map `data` 创建并返回一个哈希映射。 注意，参数 `data` 中的地图将被设置为底层数据映射（非深度拷贝），如果在外部修改此映射，可能会存在一些并发安全问题。 参数 `safe` 用于指定是否在并发安全场景下使用树结构，默认情况下为 false。

func NewHashMap别名 

func NewHashMap别名(并发安全 ...bool) *Map

NewHashMap 创建并返回一个空的哈希映射。 参数 `safe` 用于指定是否使用线程安全的 map，其默认值为 false。

func X创建 

func X创建(并发安全 ...bool) *Map

New 创建并返回一个空的哈希表。 参数`safe`用于指定是否使用线程安全的map，默认为false。

func X创建并从Map 

func X创建并从Map(map值 map[interface{}]interface{}, 并发安全 ...bool) *Map

NewFrom 创建并返回一个由给定的 `data` 地图生成的哈希映射。 注意，参数 `data` 中的地图将被设置为底层数据地图（无深度复制）， 当在外部修改该映射时，可能会存在一些并发安全问题。 参数 `safe` 用于指定是否在并发环境下使用安全的树结构，默认情况下为 false。

type StrAnyMap 

type StrAnyMap struct {
	// contains filtered or unexported fields
}

StrAnyMap 实现了带有 RWMutex（读写互斥锁）和 switch 功能的 map[string]interface{}。 ```go StrAnyMap 结构体实现了一个字符串作为键，任意类型作为值的映射，并在此基础上集成了 RWMutex， 以便在多 goroutine 并发访问时进行同步控制。同时它还可能包含 switch 相关的功能逻辑。 

type StrAnyMap struct {
    sync.RWMutex // 使用标准库中的读写互斥锁进行并发控制
    m map[string]interface{} // 存储键值对的实际映射数据结构

... 可能包含与switch相关的其他字段和方法 }

func X创建AnyStr并从Map 

func X创建AnyStr并从Map(map值 map[string]interface{}, 并发安全 ...bool) *StrAnyMap

NewStrAnyMapFrom 通过给定的映射`data`创建并返回一个哈希映射。 注意，参数`data`映射将会被设置为底层数据映射（非深度复制）， 因此在外部修改该映射时可能会存在一些并发安全问题。

func X创建StrAny 

func X创建StrAny(并发安全 ...bool) *StrAnyMap

NewStrAnyMap 返回一个空的 StrAnyMap 对象。 参数 `safe` 用于指定是否使用线程安全的 map，默认为 false。

func (*StrAnyMap) DeepCopy 

func (m *StrAnyMap) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (StrAnyMap) MarshalJSON 

func (m StrAnyMap) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。

Example 
var m map类.StrAnyMap
m.X设置值Map(g.MapStrAny{
	"k1": "v1",
	"k2": "v2",
	"k3": "v3",
	"k4": "v4",
})

bytes, err := json.Marshal(&m)
if err == nil {
	fmt.Println(转换类.String(bytes))
}

Output:

{"k1":"v1","k2":"v2","k3":"v3","k4":"v4"}

func (*StrAnyMap) String 

func (m *StrAnyMap) String() string

String 将映射转换为字符串并返回。

Example 
var m map类.StrAnyMap
m.X设置值Map(g.MapStrAny{
	"k1": "v1",
})

fmt.Println(m.String())

var m1 *map类.StrAnyMap = nil
fmt.Println(len(m1.String()))

Output:

{"k1":"v1"}
0

func (*StrAnyMap) UnmarshalJSON 

func (m *StrAnyMap) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

Example 
var m map类.StrAnyMap
m.X设置值Map(g.MapStrAny{
	"k1": "v1",
	"k2": "v2",
	"k3": "v3",
	"k4": "v4",
})

var n map类.StrAnyMap

err := json.Unmarshal(转换类.X取字节集(m.String()), &n)
if err == nil {
	fmt.Println(n.X取Map())
}

Output:

map[k1:v1 k2:v2 k3:v3 k4:v4]

func (*StrAnyMap) UnmarshalValue 

func (m *StrAnyMap) UnmarshalValue(value interface{}) (err error)

UnmarshalValue 是一个接口实现，用于为 map 设置任意类型的值。

Example 
var m map类.StrAnyMap

goWeb := map[string]interface{}{
	"goframe": "https://goframe.org",
	"gin":     "https://gin-gonic.com/",
	"echo":    "https://echo.labstack.com/",
}

if err := 转换类.Scan(goWeb, &m); err == nil {
	fmt.Printf("%#v", m.X取Map())
}

Output:

map[string]interface {}{"echo":"https://echo.labstack.com/", "gin":"https://gin-gonic.com/", "goframe":"https://goframe.org"}

func (*StrAnyMap) X出栈 

func (m *StrAnyMap) X出栈() (名称 string, 值 interface{})

Pop 从映射中检索并删除一个项目。

func (*StrAnyMap) X出栈多个 

func (m *StrAnyMap) X出栈多个(数量 int) map[string]interface{}

Pops 从映射中获取并删除 `size` 个元素。 当 size == -1 时，它返回所有元素。

func (*StrAnyMap) X删除 

func (m *StrAnyMap) X删除(名称 string) (值 interface{})

Remove通过给定的`key`从map中删除值，并返回这个被删除的值。

func (*StrAnyMap) X删除多个值 

func (m *StrAnyMap) X删除多个值(名称 []string)

删除map中通过keys指定的所有值，进行批量删除。

func (*StrAnyMap) X删除所有nil值 

func (m *StrAnyMap) X删除所有nil值()

FilterNil 删除所有值为nil的键值对。

func (*StrAnyMap) X删除所有空值 

func (m *StrAnyMap) X删除所有空值()

FilterEmpty 删除所有值为空的键值对。 以下类型的值被视为空：0, nil, false, "", 切片/映射/通道长度为0。

func (*StrAnyMap) X取Map 

func (m *StrAnyMap) X取Map() map[string]interface{}

Map 返回底层数据映射。 注意，如果它在并发安全的使用场景下，将会返回底层数据的一个副本， 否则将返回指向底层数据的指针。

func (*StrAnyMap) X取MapStrAny 

func (m *StrAnyMap) X取MapStrAny() map[string]interface{}

MapStrAny 返回该映射底层数据的一个副本，类型为 map[string]interface{}。

func (*StrAnyMap) X取值 

func (m *StrAnyMap) X取值(名称 string) (值 interface{})

Get 通过给定的 `key` 返回对应的值。

func (*StrAnyMap) X取值或设置值 

func (m *StrAnyMap) X取值或设置值(名称 string, 值 interface{}) interface{}

GetOrSet 函数通过 key 返回对应的 value， 若该 key 不存在，则使用给定的 `value` 设置并返回这个设置后的值。

func (*StrAnyMap) X取值或设置值_函数 

func (m *StrAnyMap) X取值或设置值_函数(名称 string, 回调函数 func() interface{}) interface{}

GetOrSetFunc 通过键返回值，如果该键不存在， 则使用回调函数 `f` 返回的值进行设置，并随后返回这个设置后的值。

func (*StrAnyMap) X取值或设置值_函数带锁 

func (m *StrAnyMap) X取值或设置值_函数带锁(名称 string, 回调函数 func() interface{}) interface{}

GetOrSetFuncLock 通过键返回值，如果该键不存在，则使用回调函数 `f` 返回的值设置并返回这个新值。

GetOrSetFuncLock 与 GetOrSetFunc 函数的不同之处在于，它在哈希映射的 mutex.Lock 保护下执行函数 `f`。

func (*StrAnyMap) X取值或设置值泛型类 

func (m *StrAnyMap) X取值或设置值泛型类(名称 string, 值 interface{}) *泛型类.Var

GetVarOrSet 返回一个从 GetVarOrSet 获取结果的 Var。 返回的 Var 对象不保证线程安全。

func (*StrAnyMap) X取值或设置值泛型类_函数 

func (m *StrAnyMap) X取值或设置值泛型类_函数(名称 string, 回调函数 func() interface{}) *泛型类.Var

GetVarOrSetFunc 返回一个 Var，其结果来自 GetOrSetFunc 的调用。 返回的 Var 不具备并发安全特性。

func (*StrAnyMap) X取值或设置值泛型类_函数带锁 

func (m *StrAnyMap) X取值或设置值泛型类_函数带锁(名称 string, 回调函数 func() interface{}) *泛型类.Var

GetVarOrSetFuncLock 返回一个 Var，其结果来自 GetOrSetFuncLock。 返回的 Var 不是并发安全的。

func (*StrAnyMap) X取值泛型类 

func (m *StrAnyMap) X取值泛型类(名称 string) *泛型类.Var

GetVar 通过给定的 `key` 返回一个具有相应值的 Var。 返回的 Var 不是线程安全的。

func (*StrAnyMap) X取副本 

func (m *StrAnyMap) X取副本() *StrAnyMap

Clone 返回一个新的哈希映射，其中包含当前映射数据的副本。

func (*StrAnyMap) X取所有值 

func (m *StrAnyMap) X取所有值() []interface{}

Values 返回该映射的所有值作为一个切片。

func (*StrAnyMap) X取所有名称 

func (m *StrAnyMap) X取所有名称() []string

Keys 返回该映射的所有键作为一个切片。

func (*StrAnyMap) X取数量 

func (m *StrAnyMap) X取数量() int

Size 返回映射的大小。

func (*StrAnyMap) X合并 

func (m *StrAnyMap) X合并(map值 *StrAnyMap)

Merge 合并两个哈希映射。 `other` 映射将会被合并到映射 `m` 中。

func (*StrAnyMap) X名称值交换 

func (m *StrAnyMap) X名称值交换()

Flip 将映射中的键值对进行交换，即把键变成值，值变成键。

func (*StrAnyMap) X是否为子集 

func (m *StrAnyMap) X是否为子集(父集Map *StrAnyMap) bool

IsSubOf 检查当前 map 是否为 `other` 的子集。

func (*StrAnyMap) X是否为空 

func (m *StrAnyMap) X是否为空() bool

IsEmpty 检查该映射是否为空。 如果映射为空，则返回 true，否则返回 false。

func (*StrAnyMap) X是否存在 

func (m *StrAnyMap) X是否存在(名称 string) bool

Contains 检查键是否存在。 如果 `key` 存在，则返回 true，否则返回 false。

func (*StrAnyMap) X替换 

func (m *StrAnyMap) X替换(map值 map[string]interface{})

用给定的`data`替换map中的数据。

func (*StrAnyMap) X查找 

func (m *StrAnyMap) X查找(名称 string) (值 interface{}, 成功 bool)

Search 通过给定的 `key` 在映射中搜索。 第二个返回参数 `found` 如果找到了 key，则为 true，否则为 false。

func (*StrAnyMap) X比较 

func (m *StrAnyMap) X比较(map值 *StrAnyMap) (增加的名称, 删除的名称, 更新数据的名称 []string)

Diff 函数用于比较当前映射 `m` 与映射 `other`，并返回它们不同的键。 返回的 `addedKeys` 是存在于映射 `m` 中但不在映射 `other` 中的键。 返回的 `removedKeys` 是存在于映射 `other` 中但不在映射 `m` 中的键。 返回的 `updatedKeys` 是同时存在于映射 `m` 和 `other` 中，但其对应值不相等（`!=`）的键。

func (*StrAnyMap) X浅拷贝 

func (m *StrAnyMap) X浅拷贝() map[string]interface{}

MapCopy 返回哈希映射底层数据的一个副本。

func (*StrAnyMap) X清空 

func (m *StrAnyMap) X清空()

清空删除映射中的所有数据，它会重新创建一个新的底层数据映射。

func (*StrAnyMap) X设置值 

func (m *StrAnyMap) X设置值(名称 string, 值 interface{})

Set 将键值对设置到哈希映射中。

func (*StrAnyMap) X设置值Map 

func (m *StrAnyMap) X设置值Map(map值 map[string]interface{})

Sets批量设置键值对到哈希映射中。

func (*StrAnyMap) X设置值并跳过已存在 

func (m *StrAnyMap) X设置值并跳过已存在(名称 string, 值 interface{}) bool

SetIfNotExist 如果`key`不存在，则将`value`设置到map中，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*StrAnyMap) X设置值并跳过已存在_函数 

func (m *StrAnyMap) X设置值并跳过已存在_函数(名称 string, 回调函数 func() interface{}) bool

SetIfNotExistFunc 使用回调函数`f`的返回值设置键值，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*StrAnyMap) X设置值并跳过已存在_函数带锁 

func (m *StrAnyMap) X设置值并跳过已存在_函数带锁(名称 string, 回调函数 func() interface{}) bool

SetIfNotExistFuncLock 函数用于设置键值对，其值为回调函数 `f` 的返回值，并在设置成功时返回 true。 若 `key` 已存在，则返回 false，并且将忽略 `value` 参数。

SetIfNotExistFuncLock 与 SetIfNotExistFunc 函数的区别在于， 它在执行回调函数 `f` 时会锁定哈希表的 mutex 锁。

func (*StrAnyMap) X遍历 

func (m *StrAnyMap) X遍历(回调函数 func(k string, v interface{}) bool)

Iterator 使用自定义回调函数 `f` 以只读方式迭代哈希表。 如果 `f` 返回 true，则继续迭代；如果返回 false，则停止迭代。

func (*StrAnyMap) X遍历写锁定 

func (m *StrAnyMap) X遍历写锁定(回调函数 func(m map[string]interface{}))

LockFunc 使用给定的回调函数 `f` 在 RWMutex.Lock 内锁定写入操作。

func (*StrAnyMap) X遍历读锁定 

func (m *StrAnyMap) X遍历读锁定(回调函数 func(m map[string]interface{}))

RLockFunc 在 RWMutex.RLock 内使用给定的回调函数 `f` 进行读取锁定。

type StrIntMap 

type StrIntMap struct {
	// contains filtered or unexported fields
}

StrIntMap 实现了带有 RWMutex（读写互斥锁）的 map[string]int，其中包含开关功能。

func X创建StrInt 

func X创建StrInt(并发安全 ...bool) *StrIntMap

NewStrIntMap 返回一个空的 StrIntMap 对象。 参数 `safe` 用于指定是否使用线程安全的 map，其默认值为 false。

func X创建StrInt并从Map 

func X创建StrInt并从Map(map值 map[string]int, 并发安全 ...bool) *StrIntMap

NewStrIntMapFrom 创建并返回一个从给定映射`data`生成的哈希映射。 注意，参数`data`映射将被设置为底层数据映射（非深度复制）， 因此在外部修改该映射时可能会存在一些并发安全问题。

func (*StrIntMap) DeepCopy 

func (m *StrIntMap) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (StrIntMap) MarshalJSON 

func (m StrIntMap) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。

Example 
var m map类.StrIntMap
m.X设置值Map(g.MapStrInt{
	"k1": 1,
	"k2": 2,
	"k3": 3,
	"k4": 4,
})

bytes, err := json.Marshal(&m)
if err == nil {
	fmt.Println(转换类.String(bytes))
}

Output:

{"k1":1,"k2":2,"k3":3,"k4":4}

func (*StrIntMap) String 

func (m *StrIntMap) String() string

String 将映射转换为字符串并返回。

Example 
var m map类.StrIntMap
m.X设置值Map(g.MapStrInt{
	"k1": 1,
})

fmt.Println(m.String())

var m1 *map类.StrIntMap = nil
fmt.Println(len(m1.String()))

Output:

{"k1":1}
0

func (*StrIntMap) UnmarshalJSON 

func (m *StrIntMap) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

Example 
var m map类.StrIntMap
m.X设置值Map(g.MapStrInt{
	"k1": 1,
	"k2": 2,
	"k3": 3,
	"k4": 4,
})

var n map类.StrIntMap

err := json.Unmarshal(转换类.X取字节集(m.String()), &n)
if err == nil {
	fmt.Println(n.X取Map())
}

Output:

map[k1:1 k2:2 k3:3 k4:4]

func (*StrIntMap) UnmarshalValue 

func (m *StrIntMap) UnmarshalValue(value interface{}) (err error)

UnmarshalValue 是一个接口实现，用于为 map 设置任意类型的值。

Example 
var m map类.StrIntMap

goWeb := map[string]int{
	"goframe": 1,
	"gin":     2,
	"echo":    3,
}

if err := 转换类.Scan(goWeb, &m); err == nil {
	fmt.Printf("%#v", m.X取Map())
}

Output:

map[string]int{"echo":3, "gin":2, "goframe":1}

func (*StrIntMap) X出栈 

func (m *StrIntMap) X出栈() (名称 string, 值 int)

Pop 从映射中检索并删除一个项目。

func (*StrIntMap) X出栈多个 

func (m *StrIntMap) X出栈多个(数量 int) map[string]int

Pops 从映射中获取并删除 `size` 个元素。 当 size == -1 时，它返回所有元素。

func (*StrIntMap) X删除 

func (m *StrIntMap) X删除(名称 string) (被删除值 int)

Remove通过给定的`key`从map中删除值，并返回这个被删除的值。

func (*StrIntMap) X删除多个值 

func (m *StrIntMap) X删除多个值(名称 []string)

删除map中通过keys指定的所有值，进行批量删除。

func (*StrIntMap) X删除所有空值 

func (m *StrIntMap) X删除所有空值()

FilterEmpty 删除所有值为空的键值对。 以下类型的值被视为空：0, nil, false, "", 切片/映射/通道长度为0。

func (*StrIntMap) X取Map 

func (m *StrIntMap) X取Map() map[string]int

Map 返回底层数据映射。 注意，如果它在并发安全的使用场景下，将会返回底层数据的一个副本， 否则将返回指向底层数据的指针。

func (*StrIntMap) X取MapStrAny 

func (m *StrIntMap) X取MapStrAny() map[string]interface{}

MapStrAny 返回该映射底层数据的一个副本，类型为 map[string]interface{}。

func (*StrIntMap) X取值 

func (m *StrIntMap) X取值(名称 string) (值 int)

Get 通过给定的 `key` 返回对应的值。

func (*StrIntMap) X取值或设置值 

func (m *StrIntMap) X取值或设置值(名称 string, 值 int) int

GetOrSet 函数通过 key 返回对应的 value， 若该 key 不存在，则使用给定的 `value` 设置并返回这个设置后的值。

func (*StrIntMap) X取值或设置值_函数 

func (m *StrIntMap) X取值或设置值_函数(名称 string, 回调函数 func() int) int

GetOrSetFunc 通过键返回值，如果该键不存在， 则使用回调函数 `f` 返回的值进行设置，并随后返回这个设置后的值。

func (*StrIntMap) X取值或设置值_函数带锁 

func (m *StrIntMap) X取值或设置值_函数带锁(名称 string, 回调函数 func() int) int

GetOrSetFuncLock 通过键返回值，如果该键不存在，则使用回调函数 `f` 返回的值设置并返回这个新值。

GetOrSetFuncLock 与 GetOrSetFunc 函数的不同之处在于，它在哈希映射的 mutex.Lock 保护下执行函数 `f`。

func (*StrIntMap) X取副本 

func (m *StrIntMap) X取副本() *StrIntMap

Clone 返回一个新的哈希映射，其中包含当前映射数据的副本。

func (*StrIntMap) X取所有值 

func (m *StrIntMap) X取所有值() []int

Values 返回该映射的所有值作为一个切片。

func (*StrIntMap) X取所有名称 

func (m *StrIntMap) X取所有名称() []string

Keys 返回该映射的所有键作为一个切片。

func (*StrIntMap) X取数量 

func (m *StrIntMap) X取数量() int

Size 返回映射的大小。

func (*StrIntMap) X合并 

func (m *StrIntMap) X合并(map值 *StrIntMap)

Merge 合并两个哈希映射。 `other` 映射将会被合并到映射 `m` 中。

func (*StrIntMap) X名称值交换 

func (m *StrIntMap) X名称值交换()

Flip 将映射中的键值对进行交换，即把键变成值，值变成键。

func (*StrIntMap) X是否为子集 

func (m *StrIntMap) X是否为子集(父集Map *StrIntMap) bool

IsSubOf 检查当前 map 是否为 `other` 的子集。

func (*StrIntMap) X是否为空 

func (m *StrIntMap) X是否为空() bool

IsEmpty 检查该映射是否为空。 如果映射为空，则返回 true，否则返回 false。

func (*StrIntMap) X是否存在 

func (m *StrIntMap) X是否存在(名称 string) bool

Contains 检查键是否存在。 如果 `key` 存在，则返回 true，否则返回 false。

func (*StrIntMap) X替换 

func (m *StrIntMap) X替换(map值 map[string]int)

用给定的`data`替换map中的数据。

func (*StrIntMap) X查找 

func (m *StrIntMap) X查找(名称 string) (值 int, 成功 bool)

Search 通过给定的 `key` 在映射中搜索。 第二个返回参数 `found` 如果找到了 key，则为 true，否则为 false。

func (*StrIntMap) X比较 

func (m *StrIntMap) X比较(map值 *StrIntMap) (增加的名称, 删除的名称, 更新数据的名称 []string)

Diff 函数用于比较当前映射 `m` 与映射 `other`，并返回它们不同的键。 返回的 `addedKeys` 是存在于映射 `m` 中但不在映射 `other` 中的键。 返回的 `removedKeys` 是存在于映射 `other` 中但不在映射 `m` 中的键。 返回的 `updatedKeys` 是同时存在于映射 `m` 和 `other` 中，但其对应值不相等（`!=`）的键。

func (*StrIntMap) X浅拷贝 

func (m *StrIntMap) X浅拷贝() map[string]int

MapCopy 返回哈希映射底层数据的一个副本。

func (*StrIntMap) X清空 

func (m *StrIntMap) X清空()

清空删除映射中的所有数据，它会重新创建一个新的底层数据映射。

func (*StrIntMap) X设置值 

func (m *StrIntMap) X设置值(名称 string, 值 int)

Set 将键值对设置到哈希映射中。

func (*StrIntMap) X设置值Map 

func (m *StrIntMap) X设置值Map(map值 map[string]int)

Sets批量设置键值对到哈希映射中。

func (*StrIntMap) X设置值并跳过已存在 

func (m *StrIntMap) X设置值并跳过已存在(名称 string, 值 int) bool

SetIfNotExist 如果`key`不存在，则将`value`设置到map中，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*StrIntMap) X设置值并跳过已存在_函数 

func (m *StrIntMap) X设置值并跳过已存在_函数(名称 string, 回调函数 func() int) bool

SetIfNotExistFunc 使用回调函数`f`的返回值设置键值，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*StrIntMap) X设置值并跳过已存在_函数带锁 

func (m *StrIntMap) X设置值并跳过已存在_函数带锁(名称 string, 回调函数 func() int) bool

SetIfNotExistFuncLock 函数用于设置键值对，其值为回调函数 `f` 的返回值，并在设置成功时返回 true。 若 `key` 已存在，则返回 false，并且将忽略 `value` 参数。

SetIfNotExistFuncLock 与 SetIfNotExistFunc 函数的区别在于， 它在执行回调函数 `f` 时会锁定哈希表的 mutex 锁。

func (*StrIntMap) X遍历 

func (m *StrIntMap) X遍历(回调函数 func(k string, v int) bool)

Iterator 使用自定义回调函数 `f` 以只读方式迭代哈希表。 如果 `f` 返回 true，则继续迭代；如果返回 false，则停止迭代。

func (*StrIntMap) X遍历写锁定 

func (m *StrIntMap) X遍历写锁定(回调函数 func(m map[string]int))

LockFunc 使用给定的回调函数 `f` 在 RWMutex.Lock 内锁定写入操作。

func (*StrIntMap) X遍历读锁定 

func (m *StrIntMap) X遍历读锁定(回调函数 func(m map[string]int))

RLockFunc 在 RWMutex.RLock 内使用给定的回调函数 `f` 进行读取锁定。

type StrStrMap 

type StrStrMap struct {
	// contains filtered or unexported fields
}

StrStrMap 实现了一个带有 RWMutex（读写互斥锁）和 switch 功能的 map[string]string 类型。 （译注：该结构体或类型提供了一种线程安全的方式存储和操作键值对，其中键和值都是字符串类型。通过使用 RWMutex，可以在多线程环境下进行读写操作时保证数据一致性，switch 可能是指该实现中包含了一些用于控制并发访问模式的开关功能。）

func X创建StrStr 

func X创建StrStr(并发安全 ...bool) *StrStrMap

NewStrStrMap 返回一个空的 StrStrMap 对象。 参数 `safe` 用于指定是否使用线程安全的 map， 默认为 false。

func X创建StrStr并从Map 

func X创建StrStr并从Map(map值 map[string]string, 并发安全 ...bool) *StrStrMap

NewStrStrMapFrom 通过给定的 `data` 字典创建并返回一个哈希映射。 注意，参数 `data` 字典将被直接设置为底层数据字典（非深度复制）， 因此在外部修改该字典时可能会存在并发安全问题。

func (*StrStrMap) DeepCopy 

func (m *StrStrMap) DeepCopy() interface{}

DeepCopy 实现接口，用于当前类型的深度复制。

func (StrStrMap) MarshalJSON 

func (m StrStrMap) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口所需的 MarshalJSON 方法。

Example 
var m map类.StrStrMap
m.X设置值Map(g.MapStrStr{
	"k1": "v1",
	"k2": "v2",
	"k3": "v3",
	"k4": "v4",
})

bytes, err := json.Marshal(&m)
if err == nil {
	fmt.Println(转换类.String(bytes))
}

Output:

{"k1":"v1","k2":"v2","k3":"v3","k4":"v4"}

func (*StrStrMap) String 

func (m *StrStrMap) String() string

String 将映射转换为字符串并返回。

Example 
var m map类.StrStrMap
m.X设置值Map(g.MapStrStr{
	"k1": "v1",
})

fmt.Println(m.String())

var m1 *map类.StrStrMap = nil
fmt.Println(len(m1.String()))

Output:

{"k1":"v1"}
0

func (*StrStrMap) UnmarshalJSON 

func (m *StrStrMap) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现了 json.Unmarshal 接口的 UnmarshalJSON 方法。

Example 
var m map类.StrStrMap
m.X设置值Map(g.MapStrStr{
	"k1": "v1",
	"k2": "v2",
	"k3": "v3",
	"k4": "v4",
})

var n map类.StrStrMap

err := json.Unmarshal(转换类.X取字节集(m.String()), &n)
if err == nil {
	fmt.Println(n.X取Map())
}

Output:

map[k1:v1 k2:v2 k3:v3 k4:v4]

func (*StrStrMap) UnmarshalValue 

func (m *StrStrMap) UnmarshalValue(value interface{}) (err error)

UnmarshalValue 是一个接口实现，用于为 map 设置任意类型的值。

Example 
var m map类.StrStrMap

goWeb := map[string]string{
	"goframe": "https://goframe.org",
	"gin":     "https://gin-gonic.com/",
	"echo":    "https://echo.labstack.com/",
}

if err := 转换类.Scan(goWeb, &m); err == nil {
	fmt.Printf("%#v", m.X取Map())
}

Output:

map[string]string{"echo":"https://echo.labstack.com/", "gin":"https://gin-gonic.com/", "goframe":"https://goframe.org"}

func (*StrStrMap) X出栈 

func (m *StrStrMap) X出栈() (名称, 值 string)

Pop 从映射中检索并删除一个项目。

func (*StrStrMap) X出栈多个 

func (m *StrStrMap) X出栈多个(数量 int) map[string]string

Pops 从映射中获取并删除 `size` 个元素。 当 size == -1 时，它返回所有元素。

func (*StrStrMap) X删除 

func (m *StrStrMap) X删除(名称 string) (被删除值 string)

Remove通过给定的`key`从map中删除值，并返回这个被删除的值。

func (*StrStrMap) X删除多个值 

func (m *StrStrMap) X删除多个值(名称 []string)

删除map中通过keys指定的所有值，进行批量删除。

func (*StrStrMap) X删除所有空值 

func (m *StrStrMap) X删除所有空值()

FilterEmpty 删除所有值为空的键值对。 以下类型的值被视为空：0, nil, false, "", 切片/映射/通道长度为0。

func (*StrStrMap) X取Map 

func (m *StrStrMap) X取Map() map[string]string

Map 返回底层数据映射。 注意，如果它在并发安全的使用场景下，将会返回底层数据的一个副本， 否则将返回指向底层数据的指针。

func (*StrStrMap) X取MapStrAny 

func (m *StrStrMap) X取MapStrAny() map[string]interface{}

MapStrAny 返回该映射底层数据的一个副本，类型为 map[string]interface{}。

func (*StrStrMap) X取值 

func (m *StrStrMap) X取值(名称 string) (值 string)

Get 通过给定的 `key` 返回对应的值。

func (*StrStrMap) X取值或设置值 

func (m *StrStrMap) X取值或设置值(名称 string, 值 string) string

GetOrSet 函数通过 key 返回对应的 value， 若该 key 不存在，则使用给定的 `value` 设置并返回这个设置后的值。

func (*StrStrMap) X取值或设置值_函数 

func (m *StrStrMap) X取值或设置值_函数(名称 string, 回调函数 func() string) string

GetOrSetFunc 通过键返回值，如果该键不存在， 则使用回调函数 `f` 返回的值进行设置，并随后返回这个设置后的值。

func (*StrStrMap) X取值或设置值_函数带锁 

func (m *StrStrMap) X取值或设置值_函数带锁(名称 string, 回调函数 func() string) string

GetOrSetFuncLock 通过键返回值，如果该键不存在，则使用回调函数 `f` 返回的值设置并返回这个新值。

GetOrSetFuncLock 与 GetOrSetFunc 函数的不同之处在于，它在哈希映射的 mutex.Lock 保护下执行函数 `f`。

func (*StrStrMap) X取副本 

func (m *StrStrMap) X取副本() *StrStrMap

Clone 返回一个新的哈希映射，其中包含当前映射数据的副本。

func (*StrStrMap) X取所有值 

func (m *StrStrMap) X取所有值() []string

Values 返回该映射的所有值作为一个切片。

func (*StrStrMap) X取所有名称 

func (m *StrStrMap) X取所有名称() []string

Keys 返回该映射的所有键作为一个切片。

func (*StrStrMap) X取数量 

func (m *StrStrMap) X取数量() int

Size 返回映射的大小。

func (*StrStrMap) X合并 

func (m *StrStrMap) X合并(map值 *StrStrMap)

Merge 合并两个哈希映射。 `other` 映射将会被合并到映射 `m` 中。

func (*StrStrMap) X名称值交换 

func (m *StrStrMap) X名称值交换()

Flip 将映射中的键值对进行交换，即把键变成值，值变成键。

func (*StrStrMap) X是否为子集 

func (m *StrStrMap) X是否为子集(父集Map *StrStrMap) bool

IsSubOf 检查当前 map 是否为 `other` 的子集。

func (*StrStrMap) X是否为空 

func (m *StrStrMap) X是否为空() bool

IsEmpty 检查该映射是否为空。 如果映射为空，则返回 true，否则返回 false。

func (*StrStrMap) X是否存在 

func (m *StrStrMap) X是否存在(名称 string) bool

Contains 检查键是否存在。 如果 `key` 存在，则返回 true，否则返回 false。

func (*StrStrMap) X替换 

func (m *StrStrMap) X替换(map值 map[string]string)

用给定的`data`替换map中的数据。

func (*StrStrMap) X查找 

func (m *StrStrMap) X查找(名称 string) (值 string, 成功 bool)

Search 通过给定的 `key` 在映射中搜索。 第二个返回参数 `found` 如果找到了 key，则为 true，否则为 false。

func (*StrStrMap) X比较 

func (m *StrStrMap) X比较(map值 *StrStrMap) (增加的名称, 删除的名称, 更新数据的名称 []string)

Diff 函数用于比较当前映射 `m` 与映射 `other`，并返回它们不同的键。 返回的 `addedKeys` 是存在于映射 `m` 中但不在映射 `other` 中的键。 返回的 `removedKeys` 是存在于映射 `other` 中但不在映射 `m` 中的键。 返回的 `updatedKeys` 是同时存在于映射 `m` 和 `other` 中，但其对应值不相等（`!=`）的键。

func (*StrStrMap) X浅拷贝 

func (m *StrStrMap) X浅拷贝() map[string]string

MapCopy 返回哈希映射底层数据的一个副本。

func (*StrStrMap) X清空 

func (m *StrStrMap) X清空()

清空删除映射中的所有数据，它会重新创建一个新的底层数据映射。

func (*StrStrMap) X设置值 

func (m *StrStrMap) X设置值(名称 string, 值 string)

Set 将键值对设置到哈希映射中。

func (*StrStrMap) X设置值Map 

func (m *StrStrMap) X设置值Map(map值 map[string]string)

Sets批量设置键值对到哈希映射中。

func (*StrStrMap) X设置值并跳过已存在 

func (m *StrStrMap) X设置值并跳过已存在(名称 string, 值 string) bool

SetIfNotExist 如果`key`不存在，则将`value`设置到map中，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*StrStrMap) X设置值并跳过已存在_函数 

func (m *StrStrMap) X设置值并跳过已存在_函数(名称 string, 回调函数 func() string) bool

SetIfNotExistFunc 使用回调函数`f`的返回值设置键值，并返回true。 若`key`已存在，则返回false，同时`value`将被忽略。

func (*StrStrMap) X设置值并跳过已存在_函数带锁 

func (m *StrStrMap) X设置值并跳过已存在_函数带锁(名称 string, 回调函数 func() string) bool

SetIfNotExistFuncLock 函数用于设置键值对，其值为回调函数 `f` 的返回值，并在设置成功时返回 true。 若 `key` 已存在，则返回 false，并且将忽略 `value` 参数。

SetIfNotExistFuncLock 与 SetIfNotExistFunc 函数的区别在于， 它在执行回调函数 `f` 时会锁定哈希表的 mutex 锁。

func (*StrStrMap) X遍历 

func (m *StrStrMap) X遍历(回调函数 func(k string, v string) bool)

Iterator 使用自定义回调函数 `f` 以只读方式迭代哈希表。 如果 `f` 返回 true，则继续迭代；如果返回 false，则停止迭代。

func (*StrStrMap) X遍历写锁定 

func (m *StrStrMap) X遍历写锁定(回调函数 func(m map[string]string))

LockFunc 使用给定的回调函数 `f` 在 RWMutex.Lock 内锁定写入操作。

func (*StrStrMap) X遍历读锁定 

func (m *StrStrMap) X遍历读锁定(回调函数 func(m map[string]string))

RLockFunc 在 RWMutex.RLock 内使用给定的回调函数 `f` 进行读取锁定。

type TreeMap 

type TreeMap = 树形类.RedBlackTree

TreeMap基于红黑树实现，是RedBlackTree的别名。

func X创建红黑树Map 

func X创建红黑树Map(回调函数 func(v1, v2 interface{}) int, 并发安全 ...bool) *TreeMap

NewTreeMap 创建一个使用自定义比较器的树形映射。 参数`safe`用于指定是否在并发安全的情况下使用树，其默认值为false。

func X创建红黑树Map并从Map 

func X创建红黑树Map并从Map(回调函数 func(v1, v2 interface{}) int, map值 map[interface{}]interface{}, 并发安全 ...bool) *TreeMap

NewTreeMapFrom 通过自定义比较器和`data`映射实例化一个新的树形映射。 注意，参数`data`映射将被直接设置为底层数据映射（非深度复制）， 因此在外部修改该映射时可能存在并发安全问题。 参数`safe`用于指定是否使用线程安全的树形结构，默认情况下为false。

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.