Map Go：什么决定贴图关键点的迭代顺序？

报告说：

三,。未指定映射上的迭代顺序。[……]

这是意料之中的，因为映射类型可以实现为哈希表、搜索树或其他数据结构。但是，

map

是如何在Go中实际实现的呢

换句话说，是什么决定了关键点的迭代顺序

for k, _ := range m { fmt.Println(k) }

当我看到一个带有

string

键的映射显然有一个特定的迭代顺序时，我开始对此感到疑惑。像这样的程序

package main
import ("fmt"; "time"; "rand")

func main() {
    rand.Seed(time.Seconds())
    words := [...]string{"foo", "bar", "a", "b", "c", "hello", "world",
        "0", "1", "10", "100", "123"}
    stringMap := make(map[string]byte)
    for i := range rand.Perm(len(words)) {
        stringMap[words[i]] = byte(rand.Int())
    }
    fmt.Print("stringMap keys:")
    for k, _ := range stringMap { fmt.Print(" ", k) }
    fmt.Println()
}

在我的机器上打印以下内容：

stringMap keys: a c b 100 hello foo bar 10 world 123 1 0

无论插入顺序如何

具有

map[byte]byte

map的等效程序也以无序顺序打印密钥，但此处的密钥顺序取决于插入顺序

---

这一切是如何实现的？

映射是否专门用于整数和字符串？
如果规范说没有指定迭代顺序，则不排除特定情况下的特定顺序

问题是，在任何情况下都不能依赖于这种顺序，即使在某些特殊情况下也不行。实现可以在任何给定时刻自由更改此行为，包括运行时。
请注意，如果键上有一个总的顺序，则无论插入顺序如何，顺序都是稳定的（如果键是同质类型，则经常会有）；如果没有其他内容，它可以允许对生成相同哈希的键进行有效搜索

这可能也反映了一种不同的底层实现——特别是，对于字符串，这是人们可能想要的，但是对于整数，可以使用稀疏数组来代替。
Map在Go中作为hashmap实现

Go运行时使用一个通用的hashmap实现，该实现是用C实现的。
map[string]T
和
map[byte]T
之间唯一的实现区别是：哈希函数、等价函数和复制函数

不同于（某些）C++映射，GO映射不是整数和字符串的专门化。
在Go release.r60中，只要没有键冲突，迭代顺序就与插入顺序无关。如果存在冲突，则迭代顺序受插入顺序的影响。无论键类型如何，这都适用。在这方面，
string
类型的键与
byte
类型的键没有区别，因此程序总是以相同的顺序打印字符串键，这只是巧合。除非修改映射，否则迭代顺序始终相同

但是，在最新的Go每周发行版（以及预计将于本月发行的Go1）中，迭代顺序是随机的（它从伪随机选择的键开始，哈希码计算以伪随机数为种子）。如果使用每周发行版（和Go1）编译程序，每次运行程序时迭代顺序都会不同。也就是说，无限次地运行程序可能不会打印密钥集的所有可能排列。示例输出：

stringMap keys: b 0 hello c world 10 1 123 bar foo 100 a
stringMap keys: hello world c 1 10 bar foo 123 100 a b 0
stringMap keys: bar foo 123 100 world c 1 10 b 0 hello a
...

扩展@user811773答案。半随机
range
子句迭代并不意味着返回
map
中每个元素的机会也相等。见和

主程序包
输入“fmt”
键入intSet map[int]struct{}
func（s intSet）put（v int）{s[v]=struct{}{}
func（s intSet）get（）（int，bool）{
对于k:=范围s{
返回k，true
}
返回0，false
}
func main（）{
s:=make（整数集）
对于i:=0；i<4；i++{
s、 付诸表决（i）
}
计数：=make（映射[int]int）
对于i:=0；i<1024*1024；i++{
v、 ok:=s.get（）
如果！确定{返回}
计数[v]++
}
对于k，v:=范围计数{
fmt.Printf（“值：%v，计数：%v\n”，k，v）
}
}
/*
值：1，计数：130752
值：2，计数：130833
值：0，计数：655840
数值：3，计数：131151
*/
是的，我对订单稳定并不感到惊讶。我更惊讶的是，字符串有一个独立于插入的顺序，而不是整数。@MartinGeisler这很可能反映了一个不同的底层实现；特别是，这是人们可能想要的字符串，但对于整数，可以使用稀疏数组。我知道顺序是不可靠的，即使规范没有定义顺序，也可以有顺序。感谢您的见解！很高兴知道Go 1会将其随机化，因为这样可以更容易地找到您碰巧错误地依赖于键顺序的情况。@Dysoy C源代码：谢谢，这是一个有趣的代码。不是我使用的那种hashmap代码，这一个需要几分钟来分析：@dystroy是的，代码有点非典型。另一个有趣的问题是验证hashmap实现是否安全：Go是一种安全的语言，但它也允许对同一映射进行并发读/写。因为Go是安全的，程序员不应该“发明”任意指针，因为从安全角度来看，程序可能会崩溃或易受攻击。插入键值对的代码使用
memcpy（）
是错误的。
package main

import "fmt"

type intSet map[int]struct{}

func (s intSet) put(v int) { s[v] = struct{}{} }
func (s intSet) get() (int, bool) {
    for k := range s {
        return k, true
    }
    return 0, false
}
func main() {
    s := make(intSet)
    for i := 0; i < 4; i++ {
        s.put(i)
    }
    counts := make(map[int]int)
    for i := 0; i < 1024*1024; i++ {
        v, ok := s.get()
        if !ok {return}
        counts[v]++
    }
    for k, v := range counts {
        fmt.Printf("Value: %v, Count: %v\n", k, v)
    }
}
/*
Value: 1, Count: 130752
Value: 2, Count: 130833
Value: 0, Count: 655840
Value: 3, Count: 131151
*/