自助建站最好的平台,天津葛沽 网站建设公司,服务器代理加盟,谷歌广告代理Go 复合类型之字典类型介绍 文章目录 Go 复合类型之字典类型介绍一、map类型介绍1.1 什么是 map 类型#xff1f;1.2 map 类型特性 二.map 变量的声明和初始化2.1 方法一#xff1a;使用 make 函数声明和初始化#xff08;推荐#xff09;2.2 方法二#xff1a;使用复合字…Go 复合类型之字典类型介绍 文章目录 Go 复合类型之字典类型介绍一、map类型介绍1.1 什么是 map 类型1.2 map 类型特性 二.map 变量的声明和初始化2.1 方法一使用 make 函数声明和初始化推荐2.2 方法二使用复合字面值声明初始化 map 类型变量 三.map 变量的传递开销map是引用传递四.map 的内部实现4.1 map 类型在 Go 运行时层实现的示意图4.2 初始状态4.3 tophash 区域4.4 key 存储区域4.5 value 存储区域 五.map 扩容六.map 与并发七、map 的基本操作7.1 修改和更新键值对7.2 批量更新和修改(合并同类型map)7.3 获取键值对数量7.4 查找和数据读取判断某个键是否存在7.4.1 查找和数据读取 map 语法格式7.4.2 实现get 方法查找map 对应的key 7.5 使用delete()函数删除键值对7.6 遍历 map 中的键值数据 八、Map的相等性 一、map类型介绍
1.1 什么是 map 类型
**map 是 Go 语言提供的一种抽象数据类型它表示一组无序的键值对。**用 key 和 value 分别代表 map 的键和值。而且map 集合中每个 key 都是唯一的 和切片类似作为复合类型的 map它在 Go 中的类型表示也是由 key 类型与 value 类型组成的就像下面代码
map[key_type]value_typekey 与 value 的类型可以相同也可以不同
map[string]string // key与value元素的类型相同
map[int]string // key与value元素的类型不同如果两个 map 类型的 key 元素类型相同value 元素类型也相同那么我们可以说它们是同一个 map 类型否则就是不同的 map 类型。
这里我们要注意map 类型对 value 的类型没有限制但是对 key 的类型却有严格要求因为 map 类型要保证 key 的唯一性。**因此在这里你一定要注意函数类型、map 类型自身以及切片类型是不能作为 map 的 key 类型的。**比如下面这段代码
// 函数类型不能作为key因为函数类型是不可比较的
func keyFunc() {}m : make(map[string]int)
m[keyFunc] 1 // 编译错误// map类型不能作为key
m1 : make(map[string]int)
m[m1] 1 // 编译错误// 切片类型不能作为key因为切片是可变长度的它们的内容可能会在运行时更改
s1 : []int{1,2,3}
m[s1] 1 // 编译错误上面代码中,试图使用函数类型、map类型和切片类型作为key都会导致编译错误。
这是因为Go语言在实现map时,需要比较key是否相等,因此key需要支持比较。但函数、map和切片类型的相等性比较涉及内存地址,无法简单判断,所以不能作为key。**所以key 的类型必须支持“”和“!”两种比较操作符**。
还需要注意的是在 Go 语言中函数类型、map 类型自身以及切片只支持与 nil 的比较而不支持同类型两个变量的比较。如果像下面代码这样进行这些类型的比较Go 编译器将会报错
s1 : make([]int, 1)
s2 : make([]int, 2)
f1 : func() {}
f2 : func() {}
m1 : make(map[int]string)
m2 : make(map[int]string)
println(s1 s2) // 错误invalid operation: s1 s2 (slice can only be compared to nil)
println(f1 f2) // 错误invalid operation: f1 f2 (func can only be compared to nil)
println(m1 m2) // 错误invalid operation: m1 m2 (map can only be compared to nil)1.2 map 类型特性
在Go中map具有以下特性
无序性: map中的键值对没有固定的顺序遍历时可能不按照添加的顺序返回键值对。动态增长: map是动态的它会根据需要自动增长以容纳更多的键值对不需要预先指定大小。零值: 如果未初始化一个map它将是nil并且不能存储键值对。需要使用make函数来初始化一个map。键的唯一性: 在同一个map中每个键只能出现一次。如果尝试使用相同的键插入多次新值将覆盖旧值。查询效率高: map的查询操作通常非常快因为它使用哈希表来存储数据这使得通过键查找值的时间复杂度接近常数。引用类型: map是一种引用类型多个变量可以引用并共享同一个map实例。
二.map 变量的声明和初始化
和切片一样为 map 类型变量显式赋值有两种方式一种是使用复合字面值另外一种是使用 make 这个预声明的内置函数。
2.1 方法一使用 make 函数声明和初始化推荐
这是最常见和推荐的方式特别是在需要在map中添加键值对之前初始化map的情况下。使用make函数可以为map分配内存并进行初始化。
// 使用 make 函数声明和初始化 map
myMap : make(map[keyType]valueType,capacity)其中 keyType 是键的类型。 valueType 是值的类型。 capacity表示map的初始容量,它是可选的可以省略不写。
例如和切片通过 make 进行初始化一样通过 make 的初始化方式我们可以为 map 类型变量指定键值对的初始容量但无法进行具体的键值对赋值就像下面代码这样 // 创建一个存储整数到字符串的映射m1 : make(map[int]string) // 未指定初始容量m1[1] keyfmt.Println(m1)map 类型的容量不会受限于它的初始容量值当其中的键值对数量超过初始容量后Go 运行时会自动增加 map 类型的容量保证后续键值对的正常插入比如下面这段代码 m2 : make(map[int]string, 2) // 指定初始容量为2m2[1] Onem2[2] Twom2[3] Threefmt.Println(m2) // 输出map[1:One 2:Two 3:Three] 并不会报错fmt.Println(len(m2)) // 此时map容量已经变为3总结使用make函数初始化的map是空的需要在后续代码中添加键值对。 mm : make(map[int]string)fmt.Println(mm) // 输出 map[]2.2 方法二使用复合字面值声明初始化 map 类型变量
和切片类型变量一样如果我们没有显式地赋予 map 变量初值map 类型变量的默认值为 nil比如我们来看下面这段代码
var m map[string]intif m nil {fmt.Println(Map is nil)
} else {fmt.Println(Map is not nil)
}不过切片变量和 map 变量在这里也有些不同。初值为零值 nil 的切片类型变量可以借助内置的 append 的函数进行操作这种在 Go 语言中被称为“零值可用”。定义“零值可用”的类型可以提升我们开发者的使用体验我们不用再担心变量的初始状态是否有效。比如创建一个存储字符串到整数的映射但 map 类型因为它内部实现的复杂性无法“零值可用”。所以如果我们对处于零值状态的 map 变量直接进行操作就会导致运行时异常panic从而导致程序进程异常退出
var m map[string]int // m nil
m[key] 1 // 发生运行时异常panic: assignment to entry in nil map所以我们必须对 map 类型变量进行显式初始化后才能使用。我们先来看这句代码
m : map[int]string{}这里我们显式初始化了 map 类型变量 m。不过你要注意虽然此时 map 类型变量 m 中没有任何键值对但变量 m 也不等同于初值为 nil 的 map 变量。这个时候我们对 m 进行键值对的插入操作不会引发运行时异常。
这里我们再看看怎么通过稍微复杂一些的复合字面值对 map 类型变量进行初始化
m1 : map[int][]string{1: []string{val1_1, val1_2},3: []string{val3_1, val3_2, val3_3},7: []string{val7_1},
}type Position struct { x float64 y float64
}m2 : map[Position]string{Position{29.935523, 52.568915}: school,Position{25.352594, 113.304361}: shopping-mall,Position{73.224455, 111.804306}: hospital,
}我们看到上面代码虽然完成了对两个 map 类型变量 m1 和 m2 的显式初始化但不知道你有没有发现一个问题作为初值的字面值似乎有些“臃肿”。你看作为初值的字面值采用了复合类型的元素类型而且在编写字面值时还带上了各自的元素类型比如作为 map[int] []string 值类型的[]string以及作为 map[Position]string 的 key 类型的 Position。
别急针对这种情况Go 提供了“语法糖”。这种情况下**Go 允许省略字面值中的元素类型。**因为 map 类型表示中包含了 key 和 value 的元素类型Go 编译器已经有足够的信息来推导出字面值中各个值的类型了。我们以 m2 为例这里的显式初始化代码和上面变量 m2 的初始化代码是等价的
m2 : map[Position]string{{29.935523, 52.568915}: school,{25.352594, 113.304361}: shopping-mall,{73.224455, 111.804306}: hospital,
}综上这种方式通常用于创建具有初始值的map。在这种情况下不需要使用make函数。map的声明方式如下
// 使用字面量声明和初始化 map
myMap : map[keyType]valueType{key1: value1,key2: value2,// ...
}
其中
keyType 是键的类型valueType 是值的类型然后使用大括号 {} 包围键值对
三.map 变量的传递开销map是引用传递
和切片类型一样map 也是引用类型。这就意味着 map 类型变量作为参数被传递给函数或方法的时候实质上传递的只是一个“描述符”而不是整个 map 的数据拷贝所以这个传递的开销是固定的而且也很小。
并且当 map 变量被传递到函数或方法内部后我们在函数内部对 map 类型参数的修改在函数外部也是可见的。比如你从这个示例中就可以看到函数 foo 中对 map 类型变量 m 进行了修改而这些修改在 foo 函数外也可见。
package mainimport fmtfunc foo(m map[string]int) {m[key1] 11m[key2] 12
}func main() {m : map[string]int{key1: 1,key2: 2,}fmt.Println(m) // map[key1:1 key2:2] foo(m)fmt.Println(m) // map[key1:11 key2:12]
}所以map 引用类型。当 map 被赋值为一个新变量的时候它们指向同一个内部数据结构。因此当改变其中一个变量就会影响到另一变量。
四.map 的内部实现
4.1 map 类型在 Go 运行时层实现的示意图
和切片相比map 类型的内部实现要更加复杂。Go 运行时使用一张哈希表来实现抽象的 map 类型。运行时实现了 map 类型操作的所有功能包括查找、插入、删除等。在编译阶段Go 编译器会将 Go 语法层面的 map 操作重写成运行时对应的函数调用。大致的对应关系是这样的
// 创建map类型变量实例
m : make(map[keyType]valType, capacityhint) → m : runtime.makemap(maptype, capacityhint, m)// 插入新键值对或给键重新赋值
m[key] value → v : runtime.mapassign(maptype, m, key) v是用于后续存储value的空间的地址// 获取某键的值
v : m[key] → v : runtime.mapaccess1(maptype, m, key)
v, ok : m[key] → v, ok : runtime.mapaccess2(maptype, m, key)// 删除某键
delete(m, key) → runtime.mapdelete(maptype, m, “key”)这是 map 类型在 Go 运行时层实现的示意图 我们可以看到和切片的运行时表示图相比map 的实现示意图显然要复杂得多。接下来我们结合这张图来简要描述一下 map 在运行时层的实现原理。接下来我们来看一下一个 map 变量在初始状态、进行键值对操作后以及在并发场景下的 Go 运行时层的实现原理。
4.2 初始状态
从图中我们可以看到与语法层面 map 类型变量m一一对应的是 *runtime.hmap 的实例即 runtime.hmap 类型的指针也就是我们前面在讲解 map 类型变量传递开销时提到的 map 类型的描述符。hmap 类型是 map 类型的头部结构header它存储了后续 map 类型操作所需的所有信息包括 真正用来存储键值对数据的是桶也就是 bucket每个 bucket 中存储的是 Hash 值低 bit 位数值相同的元素默认的元素个数为 BUCKETSIZE值为 8Go 1.17 版本中在 $GOROOT/src/cmd/compile/internal/reflectdata/reflect.go 中定义与 runtime/map.go 中常量 bucketCnt 保持一致。
当某个 bucket比如 buckets[0]) 的 8 个空槽 slot都填满了且 map 尚未达到扩容的条件的情况下运行时会建立 overflow bucket并将这个 overflow bucket 挂在上面 bucket如 buckets[0]末尾的 overflow 指针上这样两个 buckets 形成了一个链表结构直到下一次 map 扩容之前这个结构都会一直存在。
从图中我们可以看到每个 bucket 由三部分组成从上到下分别是 tophash 区域、key 存储区域和 value 存储区域。
4.3 tophash 区域
当我们向 map 插入一条数据或者是从 map 按 key 查询数据的时候运行时都会使用哈希函数对 key 做哈希运算并获得一个哈希值hashcode。这个 hashcode 非常关键运行时会把 hashcode“一分为二”来看待其中低位区的值用于选定 bucket高位区的值用于在某个 bucket 中确定 key 的位置。我把这一过程整理成了下面这张示意图你理解起来可以更直观 因此每个 bucket 的 tophash 区域其实是用来快速定位 key 位置的这样就避免了逐个 key 进行比较这种代价较大的操作。尤其是当 key 是 size 较大的字符串类型时好处就更突出了。这是一种以空间换时间的思路。
4.4 key 存储区域
接着我们看 tophash 区域下面是一块连续的内存区域存储的是这个 bucket 承载的所有 key 数据。运行时在分配 bucket 的时候需要知道 key 的 Size。那么运行时是如何知道 key 的 size 的呢
当我们声明一个 map 类型变量比如 var m map[string]int 时Go 运行时就会为这个变量对应的特定 map 类型生成一个 runtime.maptype 实例。如果这个实例已经存在就会直接复用。maptype 实例的结构是这样的
type maptype struct {typ _typekey *_typeelem *_typebucket *_type // internal type representing a hash bucketkeysize uint8 // size of key slotelemsize uint8 // size of elem slotbucketsize uint16 // size of bucketflags uint32
} 我们可以看到这个实例包含了我们需要的 map 类型中的所有元信息。我们前面提到过编译器会把语法层面的 map 操作重写成运行时对应的函数调用这些运行时函数都有一个共同的特点那就是第一个参数都是 maptype 指针类型的参数。
Go 运行时就是利用 maptype 参数中的信息确定 key 的类型和大小的。map 所用的 hash 函数也存放在 maptype.key.alg.hash(key, hmap.hash0) 中。同时 maptype 的存在也让 Go 中所有 map 类型都共享一套运行时 map 操作函数而不是像 C 那样为每种 map 类型创建一套 map 操作函数这样就节省了对最终二进制文件空间的占用。
4.5 value 存储区域
我们再接着看 key 存储区域下方的另外一块连续的内存区域这个区域存储的是 key 对应的 value。和 key 一样这个区域的创建也是得到了 maptype 中信息的帮助。Go 运行时采用了把 key 和 value 分开存储的方式而不是采用一个 kv 接着一个 kv 的 kv 紧邻方式存储这带来的其实是算法上的复杂性但却减少了因内存对齐带来的内存浪费。
我们以 map[int8]int64 为例看看下面的存储空间利用率对比图 你会看到当前 Go 运行时使用的方案内存利用效率很高而 kv 紧邻存储的方案在 map[int8]int64 这样的例子中内存浪费十分严重它的内存利用率是 72/12856.25%有近一半的空间都浪费掉了。
另外还有一点我要跟你强调一下如果 key 或 value 的数据长度大于一定数值那么运行时不会在 bucket 中直接存储数据而是会存储 key 或 value 数据的指针。目前 Go 运行时定义的最大 key 和 value 的长度是这样的
// $GOROOT/src/runtime/map.go
const (maxKeySize 128maxElemSize 128
)五.map 扩容
我们前面提到过map 会对底层使用的内存进行自动管理。因此在使用过程中当插入元素个数超出一定数值后map 一定会存在自动扩容的问题也就是怎么扩充 bucket 的数量并重新在 bucket 间均衡分配数据的问题。
那么 map 在什么情况下会进行扩容呢Go 运行时的 map 实现中引入了一个 LoadFactor负载因子当 count LoadFactor * 2^B 或 overflow bucket 过多时运行时会自动对 map 进行扩容。目前 Go 1.17 版本 LoadFactor 设置为 6.5loadFactorNum/loadFactorDen。这里是 Go 中与 map 扩容相关的部分源码
// $GOROOT/src/runtime/map.go
const (... ...loadFactorNum 13loadFactorDen 2... ...
)func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {... ...if !h.growing() (overLoadFactor(h.count1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {hashGrow(t, h)goto again // Growing the table invalidates everything, so try again}... ...
}这两方面原因导致的扩容在运行时的操作其实是不一样的。如果是因为 overflow bucket 过多导致的“扩容”实际上运行时会新建一个和现有规模一样的 bucket 数组然后在 assign 和 delete 时做排空和迁移。
如果是因为当前数据数量超出 LoadFactor 指定水位而进行的扩容那么运行时会建立一个两倍于现有规模的 bucket 数组但真正的排空和迁移工作也是在 assign 和 delete 时逐步进行的。原 bucket 数组会挂在 hmap 的 oldbuckets 指针下面直到原 buckets 数组中所有数据都迁移到新数组后原 buckets 数组才会被释放。你可以结合下面的 map 扩容示意图来理解这个过程这会让你理解得更深刻一些 六.map 与并发
接着我们来看一下 map 和并发。从上面的实现原理来看充当 map 描述符角色的 hmap 实例自身是有状态的hmap.flags而且对状态的读写是没有并发保护的。所以说 map 实例不是并发写安全的也不支持并发读写。如果我们对 map 实例进行并发读写程序运行时就会抛出异常。你可以看看下面这个并发读写 map 的例子
package mainimport (fmttime
)func doIteration(m map[int]int) {for k, v : range m {_ fmt.Sprintf([%d, %d] , k, v)}
}func doWrite(m map[int]int) {for k, v : range m {m[k] v 1}
}func main() {m : map[int]int{1: 11,2: 12,3: 13,}go func() {for i : 0; i 1000; i {doIteration(m)}}()go func() {for i : 0; i 1000; i {doWrite(m)}}()time.Sleep(5 * time.Second)
}运行这个示例程序我们会得到下面的执行错误结果
fatal error: concurrent map iteration and map write不过如果我们仅仅是进行并发读map 是没有问题的。而且Go 1.9 版本中引入了支持并发写安全的 sync.Map 类型可以在并发读写的场景下替换掉 map。如果你有这方面的需求可以查看一下sync.Map 的手册。
另外你要注意考虑到 map 可以自动扩容map 中数据元素的 value 位置可能在这一过程中发生变化所以 Go 不允许获取 map 中 value 的地址这个约束是在编译期间就生效的。下面这段代码就展示了 Go 编译器识别出获取 map 中 value 地址的语句后给出的编译错误
p : m[key] // cannot take the address of m[key]
fmt.Println(p)七、map 的基本操作
7.1 修改和更新键值对
首先 nil 的 map 类型变量我们可以在其中插入符合 map 类型定义的任意新键值对。插入新键值对只需要把 value 赋值给 map 中对应的 key 就可以了
// 创建并初始化一个 map
myMap : make(map[string]int)
myMap[apple] 1
myMap[banana] 2不需要自己判断数据有没有插入成功因为 Go 会保证插入总是成功的。不过如果我们插入新键值对的时候某个 key 已经存在于 map 中了那我们的插入操作就会用新值覆盖旧值
// 修改键 apple 对应的值
myMap[apple] 3// 更新键 cherry 对应的值如果键不存在则创建新键值对
myMap[cherry] 4// 打印修改后的 map
fmt.Println(myMap) // 输出: map[apple:3 banana:2 cherry:4]从这段代码中您可以看到如何执行以下操作
修改键 “apple” 对应的值使用myMap[apple] 3这行代码将键 “apple” 对应的值从原来的 1 修改为 3。更新键 “cherry” 对应的值使用myMap[cherry] 4这行代码更新了键 “cherry” 对应的值为 4。如果键 “cherry” 不存在于map中这行代码会创建一个新的键值对。打印修改后的 map最后使用fmt.Println(myMap)打印整个修改后的map以显示更新后的键值对。
7.2 批量更新和修改(合并同类型map)
在Go中可以使用循环遍历另一个map然后使用遍历的键值对来批量更新或修改目标map的键值对。以下是一个实现类似于Python字典的update()方法的步骤
创建一个目标map它将被更新或修改。创建一个源map其中包含要合并到目标map的键值对。遍历源map的键值对。对于每个键值对检查它是否存在于目标map中。 如果存在将目标map中的值更新为源map中的值。如果不存在将源map中的键值对添加到目标map中。 最终目标map将包含源map中的所有键值对以及更新后的值。
以下是具体的Go代码示例
package mainimport (fmt
)
func updateMap(target map[string]int, source map[string]int) {for key, value : range source {target[key] value}
}
func main() {// 创建目标 maptargetMap : map[string]int{apple: 1,banana: 2,}// 创建源 map包含要更新或修改的键值对sourceMap : map[string]int{apple: 3, // 更新 apple 的值为 3cherry: 4, // 添加新的键值对 cherry: 4}// 调用 updateMap 函数将源 map 合并到目标 map 中updateMap(targetMap, sourceMap)// 打印更新后的目标 mapfmt.Println(targetMap) // 输出map[apple:3 banana:2 cherry:4]
}7.3 获取键值对数量
要获取一个map中键值对的数量也称为长度可以使用Go语言的len函数。len函数返回map中键值对的数量。以下是获取map中键值对数量的示例 // 创建并初始化一个 mapmyMap : map[string]int{apple: 1,banana: 2,cherry: 3,}// 使用 len 函数获取 map 的键值对数量count : len(myMap)// 打印键值对数量fmt.Println(键值对数量:, count)不过这里要注意的是我们不能对 map 类型变量调用 cap来获取当前容量这是 map 类型与切片类型的一个不同点。
7.4 查找和数据读取判断某个键是否存在
7.4.1 查找和数据读取 map 语法格式
Go语言中有个判断map中键是否存在的特殊写法格式如下:
value, ok : map[key]其中
myMap 是目标map您希望在其中查找键。key 是您要查找的键。value 是一个变量如果键存在它将存储键对应的值如果键不存在则会获得值类型的零值。ok 是一个布尔值用于指示键是否存在。如果键存在ok为true如果键不存在ok为false。
map 类型更多用在查找和数据读取场合。所谓查找就是判断某个 key 是否存在于某个 map 中。Go 语言的 map 类型支持通过用一种名为“comma ok”的惯用法进行对某个 key 的查询。接下来我们就用“comma ok”惯用法改造一下上面的代码
m : make(map[string]int)
v, ok : m[key1]
if !ok {// key1不在map中
}// key1在map中v将被赋予key1键对应的value我们看到这里我们通过了一个布尔类型变量 ok来判断键“key1”是否存在于 map 中。如果存在变量 v 就会被正确地赋值为键“key1”对应的 value。
不过如果我们并不关心某个键对应的 value而只关心某个键是否在于 map 中我们可以使用空标识符替代变量 v忽略可能返回的 value
m : make(map[string]int)
_, ok : m[key1]
... ...因此你一定要记住在 Go 语言中请使用“comma ok”惯用法对 map 进行键查找和键值读取操作。
7.4.2 实现get 方法查找map 对应的key
在Go中要实现类似Python字典的get()方法可以编写一个函数该函数接受一个map、一个键以及一个默认值作为参数。函数将尝试从map中获取指定键的值如果键不存在则返回默认值。以下是实现类似get()方法的步骤
创建一个函数命名为get该函数接受三个参数map、键和默认值。在函数中使用键来尝试从map中获取对应的值。如果值存在返回该值如果不存在则返回默认值空字符串。
package mainimport (fmt
)// 实现类似 Python 字典的 get() 方法
func get(myMap map[string]string, key string) string {value, ok : myMap[key]if !ok {return }return value
}func main() {// 创建并初始化一个 mapmyMap : map[string]string{apple: red,banana: yellow,cherry: red,}// 使用 get() 方法获取键 apple 的值如果不存在返回空字符串appleValue : get(myMap, apple)fmt.Println(Color of apple:, appleValue)// 使用 get() 方法获取键 tangerine 的值如果不存在返回空字符串grapeValue : get(myMap, tangerine)if grapeValue {fmt.Println(没有获取到tangerine的对应的值)} else {fmt.Println(Color of tangerine:, grapeValue)}
}
运行此代码将输出
Color of apple: red
没有获取到tangerine的对应的值7.5 使用delete()函数删除键值对
使用delete()内建函数从map中删除一组键值对delete()函数的格式如下
delete(map, key)其中
map:表示要删除键值对的mapkey:表示要删除的键值对的键
使用 delete 函数的情况下传入的第一个参数是我们的 map 类型变量第二个参数就是我们想要删除的键。我们可以看看这个代码示例
m : map[string]int {key1 : 1,key2 : 2,
}fmt.Println(m) // map[key1:1 key2:2]
delete(m, key2) // 删除key2
fmt.Println(m) // map[key1:1]7.6 遍历 map 中的键值数据
最后我们来说一下如何遍历 map 中的键值数据。这一点虽然不像查询和读取操作那么常见但日常开发中我们还是有这个需求的。在 Go 中遍历 map 的键值对只有一种方法那就是像对待切片那样通过 for range 语句对 map 数据进行遍历。我们看一个例子
package mainimport fmtfunc main() {m : map[int]int{1: 11,2: 12,3: 13,}fmt.Printf({ )for k, v : range m {fmt.Printf([%d, %d] , k, v)}fmt.Printf(}\n)
}你看通过 for range 遍历 map 变量 m每次迭代都会返回一个键值对其中键存在于变量 k 中它对应的值存储在变量 v 中。我们可以运行一下这段代码可以得到符合我们预期的结果
{ [1, 11] [2, 12] [3, 13] }如果我们只关心每次迭代的键我们可以使用下面的方式对 map 进行遍历
for k, _ : range m { // 使用k
}当然更地道的方式是这样的
for k : range m {// 使用k
}如果我们只关心每次迭代返回的键所对应的 value我们同样可以通过空标识符替代变量 k就像下面这样
for _, v : range m {// 使用v
}不过前面 map 遍历的输出结果都非常理想给我们的表象好像是迭代器按照 map 中元素的插入次序逐一遍历。那事实是不是这样呢我们再来试试多遍历几次这个 map 看看。
我们先来改造一下代码
package mainimport fmtfunc doIteration(m map[int]int) {fmt.Printf({ )for k, v : range m {fmt.Printf([%d, %d] , k, v)}fmt.Printf(}\n)
}func main() {m : map[int]int{1: 11,2: 12,3: 13,}for i : 0; i 3; i {doIteration(m)}
}运行一下上述代码我们可以得到这样结果
{ [1, 11] [2, 12] [3, 13] }
{ [2, 12] [3, 13] [1, 11] }
{ [1, 11] [2, 12] [3, 13] }我们可以看到对同一 map 做多次遍历的时候每次遍历元素的次序都不相同。这是 Go 语言 map 类型的一个重要特点也是很容易让 Go 初学者掉入坑中的一个地方。所以这里你一定要记住程序逻辑千万不要依赖遍历 map 所得到的的元素次序。
八、Map的相等性
map 之间不能使用 操作符判断 只能用来检查 map 是否为 nil。
func main() {map1 : map[string]int{one: 1,two: 2,}map2 : map1if map1 nil{fmt.Println(map1为空)}else {fmt.Println(map1不为空)}if map1 map2 { // 直接报错不能直接比较}}
