4dfc289ae5
The index expression and delete keyword are valid on nil maps, so the runtime must be modified to support this.
139 строки
3,3 КиБ
Go
139 строки
3,3 КиБ
Go
package main
|
|
|
|
var testmap1 = map[string]int{"data": 3}
|
|
var testmap2 = map[string]int{
|
|
"one": 1,
|
|
"two": 2,
|
|
"three": 3,
|
|
"four": 4,
|
|
"five": 5,
|
|
"six": 6,
|
|
"seven": 7,
|
|
"eight": 8,
|
|
"nine": 9,
|
|
"ten": 10,
|
|
"eleven": 11,
|
|
"twelve": 12,
|
|
}
|
|
|
|
type ArrayKey [4]byte
|
|
|
|
var testMapArrayKey = map[ArrayKey]int{
|
|
ArrayKey([4]byte{1, 2, 3, 4}): 1234,
|
|
ArrayKey([4]byte{4, 3, 2, 1}): 4321,
|
|
}
|
|
var testmapIntInt = map[int]int{1: 1, 2: 4, 3: 9}
|
|
|
|
type namedFloat struct {
|
|
s string
|
|
f float32
|
|
}
|
|
|
|
func main() {
|
|
m := map[string]int{"answer": 42, "foo": 3}
|
|
readMap(m, "answer")
|
|
readMap(testmap1, "data")
|
|
readMap(testmap2, "three")
|
|
readMap(testmap2, "ten")
|
|
delete(testmap2, "six")
|
|
readMap(testmap2, "seven")
|
|
lookup(testmap2, "eight")
|
|
lookup(testmap2, "nokey")
|
|
|
|
// operations on nil maps
|
|
var nilmap map[string]int
|
|
println(m == nil, m != nil, len(m))
|
|
println(nilmap == nil, nilmap != nil, len(nilmap))
|
|
delete(nilmap, "foo")
|
|
println("nilmap:", nilmap["bar"])
|
|
println(testmapIntInt[2])
|
|
testmapIntInt[2] = 42
|
|
println(testmapIntInt[2])
|
|
|
|
arrKey := ArrayKey([4]byte{4, 3, 2, 1})
|
|
println(testMapArrayKey[arrKey])
|
|
testMapArrayKey[arrKey] = 5555
|
|
println(testMapArrayKey[arrKey])
|
|
|
|
// test maps with interface keys
|
|
itfMap := map[interface{}]int{
|
|
3.14: 3,
|
|
8: 8,
|
|
uint8(8): 80,
|
|
"eight": 800,
|
|
[2]int{5, 2}: 52,
|
|
true: 1,
|
|
}
|
|
println("itfMap[3]:", itfMap[3]) // doesn't exist
|
|
println("itfMap[3.14]:", itfMap[3.14])
|
|
println("itfMap[8]:", itfMap[8])
|
|
println("itfMap[uint8(8)]:", itfMap[uint8(8)])
|
|
println(`itfMap["eight"]:`, itfMap["eight"])
|
|
println(`itfMap[[2]int{5, 2}]:`, itfMap[[2]int{5, 2}])
|
|
println("itfMap[true]:", itfMap[true])
|
|
delete(itfMap, 8)
|
|
println("itfMap[8]:", itfMap[8])
|
|
|
|
// test map with float keys
|
|
floatMap := map[float32]int{
|
|
42: 84,
|
|
}
|
|
println("floatMap[42]:", floatMap[42])
|
|
println("floatMap[43]:", floatMap[43])
|
|
delete(floatMap, 42)
|
|
println("floatMap[42]:", floatMap[42])
|
|
|
|
// test maps with struct keys
|
|
structMap := map[namedFloat]int{
|
|
namedFloat{"tau", 6.28}: 5,
|
|
}
|
|
println(`structMap[{"tau", 6.28}]:`, structMap[namedFloat{"tau", 6.28}])
|
|
println(`structMap[{"Tau", 6.28}]:`, structMap[namedFloat{"Tau", 6.28}])
|
|
println(`structMap[{"tau", 3.14}]:`, structMap[namedFloat{"tau", 3.14}])
|
|
delete(structMap, namedFloat{"tau", 6.28})
|
|
println(`structMap[{"tau", 6.28}]:`, structMap[namedFloat{"tau", 6.28}])
|
|
|
|
// test preallocated map
|
|
squares := make(map[int]int, 200)
|
|
testBigMap(squares, 100)
|
|
println("tested preallocated map")
|
|
|
|
// test growing maps
|
|
squares = make(map[int]int, 0)
|
|
testBigMap(squares, 10)
|
|
squares = make(map[int]int, 20)
|
|
testBigMap(squares, 40)
|
|
println("tested growing of a map")
|
|
}
|
|
|
|
func readMap(m map[string]int, key string) {
|
|
println("map length:", len(m))
|
|
println("map read:", key, "=", m[key])
|
|
for k, v := range m {
|
|
println(" ", k, "=", v)
|
|
}
|
|
}
|
|
|
|
func lookup(m map[string]int, key string) {
|
|
value, ok := m[key]
|
|
println("lookup with comma-ok:", key, value, ok)
|
|
}
|
|
|
|
func testBigMap(squares map[int]int, n int) {
|
|
for i := 0; i < n; i++ {
|
|
if len(squares) != i {
|
|
println("unexpected length:", len(squares), "at i =", i)
|
|
}
|
|
squares[i] = i * i
|
|
for j := 0; j <= i; j++ {
|
|
if v, ok := squares[j]; !ok || v != j*j {
|
|
if !ok {
|
|
println("key not found in squares map:", j)
|
|
} else {
|
|
println("unexpected value read back from squares map:", j, v)
|
|
}
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|