Kubernetes
Kubernetes
从语法上看,是可以的。Go 语言中只要是可比较的类型都可以作为 key。除开 slice,map,functions 这几种类型,其他类型都是 OK 的。具体包括:布尔值、数字、字符串、指针、通道、接口类型、结构体、只包含上述类型的数组。这些类型的共同特征是支持 ==
和 !=
操作符,k1 == k2
时,可认为 k1 和 k2 是同一个 key。如果是结构体,只有 hash 后的值相等以及字面值相等,才被认为是相同的 key。很多字面值相等的,hash出来的值不一定相等,比如引用。
顺便说一句,任何类型都可以作为 value,包括 map 类型。
来看个例子:
1func main() {
2 m := make(map[float64]int)
3 m[1.4] = 1
4 m[2.4] = 2
5 m[math.NaN()] = 3
6 m[math.NaN()] = 3
7
8 for k, v := range m {
9 fmt.Printf("[%v, %d] ", k, v)
10 }
11
12 fmt.Printf("\nk: %v, v: %d\n", math.NaN(), m[math.NaN()])
13 fmt.Printf("k: %v, v: %d\n", 2.400000000001, m[2.400000000001])
14 fmt.Printf("k: %v, v: %d\n", 2.4000000000000000000000001, m[2.4000000000000000000000001])
15
16 fmt.Println(math.NaN() == math.NaN())
17}
程序的输出:
1[2.4, 2] [NaN, 3] [NaN, 3] [1.4, 1]
2k: NaN, v: 0
3k: 2.400000000001, v: 0
4k: 2.4, v: 2
5false
例子中定义了一个 key 类型是 float 型的 map,并向其中插入了 4 个 key:1.4, 2.4, NAN,NAN。
打印的时候也打印出了 4 个 key,如果你知道 NAN != NAN,也就不奇怪了。因为他们比较的结果不相等,自然,在 map 看来就是两个不同的 key 了。
接着,我们查询了几个 key,发现 NAN 不存在,2.400000000001 也不存在,而 2.4000000000000000000000001 却存在。
有点诡异,不是吗?
接着,我通过汇编发现了如下的事实:
当用 float64 作为 key 的时候,先要将其转成 unit64 类型,再插入 key 中。
具体是通过 Float64frombits
函数完成:
1// Float64frombits returns the floating point number corresponding
2// the IEEE 754 binary representation b.
3func Float64frombits(b uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
也就是将浮点数表示成 IEEE 754 规定的格式。如赋值语句:
10x00bd 00189 (test18.go:9) LEAQ "".statictmp_0(SB), DX
20x00c4 00196 (test18.go:9) MOVQ DX, 16(SP)
30x00c9 00201 (test18.go:9) PCDATA $0, $2
40x00c9 00201 (test18.go:9) CALL runtime.mapassign(SB)
"".statictmp_0(SB)
变量是这样的:
1"".statictmp_0 SRODATA size=8
2 0x0000 33 33 33 33 33 33 03 40
3"".statictmp_1 SRODATA size=8
4 0x0000 ff 3b 33 33 33 33 03 40
5"".statictmp_2 SRODATA size=8
6 0x0000 33 33 33 33 33 33 03 40
我们再来输出点东西:
1package main
2
3import (
4 "fmt"
5 "math"
6)
7
8func main() {
9 m := make(map[float64]int)
10 m[2.4] = 2
11
12 fmt.Println(math.Float64bits(2.4))
13 fmt.Println(math.Float64bits(2.400000000001))
14 fmt.Println(math.Float64bits(2.4000000000000000000000001))
15}
14612586738352862003
24612586738352864255
34612586738352862003
转成十六进制为:
10x4003333333333333
20x4003333333333BFF
30x4003333333333333
和前面的 "".statictmp_0
比较一下,很清晰了吧。2.4
和 2.4000000000000000000000001
经过 math.Float64bits()
函数转换后的结果是一样的。自然,二者在 map 看来,就是同一个 key 了。
再来看一下 NAN(not a number):
1// NaN returns an IEEE 754 ``not-a-number'' value.
2func NaN() float64 { return Float64frombits(uvnan) }
uvan 的定义为:
1uvnan = 0x7FF8000000000001
NAN() 直接调用 Float64frombits
,传入写死的 const 型变量 0x7FF8000000000001
,得到 NAN 型值。既然,NAN 是从一个常量解析得来的,为什么插入 map 时,会被认为是不同的 key?
这是由类型的哈希函数决定的,例如,对于 64 位的浮点数,它的哈希函数如下:
1func f64hash(p unsafe.Pointer, h uintptr) uintptr {
2 f := *(*float64)(p)
3 switch {
4 case f == 0:
5 return c1 * (c0 ^ h) // +0, -0
6 case f != f:
7 return c1 * (c0 ^ h ^ uintptr(fastrand())) // any kind of NaN
8 default:
9 return memhash(p, h, 8)
10 }
11}
第二个 case,f != f
就是针对 NAN
,这里会再加一个随机数。
这样,所有的谜题都解开了。
由于 NAN 的特性:
1NAN != NAN
2hash(NAN) != hash(NAN)
因此向 map 中查找的 key 为 NAN 时,什么也查不到;如果向其中增加了 4 次 NAN,遍历会得到 4 个 NAN。
最后说结论:float 型可以作为 key,但是由于精度的问题,会导致一些诡异的问题,慎用之。
关于当 key 是引用类型时,判断两个 key 是否相等,需要 hash 后的值相等并且 key 的字面量相等。由 @WuMingyu 补充的例子:
1func TestT(t *testing.T) {
2 type S struct {
3 ID int
4 }
5 s1 := S{ID: 1}
6 s2 := S{ID: 1}
7
8 var h = map[*S]int {}
9 h[&s1] = 1
10 t.Log(h[&s1])
11 t.Log(h[&s2])
12 t.Log(s1 == s2)
13}
test output:
1=== RUN TestT
2--- PASS: TestT (0.00s)
3 endpoint_test.go:74: 1
4 endpoint_test.go:75: 0
5 endpoint_test.go:76: true
6PASS
7
8Process finished with exit code 0