字典

除了内置的基本类型外,数组和字典也是内置类型

map实现

从map的源代码定义看,map是通过2个struct实现的

vlib/builtin/map.v

1. struct map {
2. root &mapnode //字典第一个键值对的地址
3. element_size int //一个键值对元素占用的内存大小
4. pub:
5. size int //字典的大小,也就是键值对的数量,这是map唯一可以对外直接访问的属性,只读
6. }
7. struct mapnode {  //键值对节点
8. left &mapnode
9. right &mapnode
10. is_empty bool
11. key string //键,目前只能是string类型
12. value voidptr //值的地址,值可以是任何类型
13. }

map定义

1. fn main() {
2. mut m := map[string]int{}
3. m['one'] = 1
4. m['two'] = 2
5. println(m['one']) //返回对应的value
6. println(m['bad_key']) // 如果指定key不存在,返回0
7. }

map的key除了string类型,也可以是其他类型

string类型的key

1. map[string]int
2. map[string]User
3. map[string][]int

非string类型的key

1. module main

3. enum Token {
4. aa = 2
5. bb
6. cc
7. }

9. fn main() {
10. //非字符串key
11. // int key 整数
12. mut m1 := map[int]int{}
13. m1[3] = 9
14. m1[4] = 16
15. println(m1)
16. // voidptr key 通用指针
17. mut m2 := map[voidptr]string{}
18. v := 5
19. m2[&v] = 'var'
20. m2[&m2] = 'map'
21. println(m2)
22. //rune key unicode码
23. mut m3 := {
24. `!`: 2 //是反引号`,不是单引号'
25. `%`: 3
26. }
27. println(typeof(m3).name) // map[rune]int
28. println(m3)
29. // byte key 字节
30. mut m4 := map[byte]string{}
31. m4[byte(1)] = 'a'
32. m4[byte(2)] = 'b'
33. println(m4)
34. // float key 小数
35. mut m5 := map[f64]string{}
36. m5[1.2] = 'a'
37. m5[2.0] = 'b'
38. println(m5)
39. // enum key 枚举值
40. mut m6 := map[Token]string{}
41. m6[Token.aa] = 'abc'
42. m6[Token.bb] = 'def'
43. println(m6)
44. }

map字面量初始化

1. fn main() {
2. m := map {'one':1,'two':2,'three':3}
3. m2 := map {1 :'a', 2 :'b', 3 :'c'}
4. println(m)
5. println(m2)
6. }

map.len返回字典的大小

1. fn main() {
2. mut m := map[string]int{}
3. m['one'] = 1
4. m['two'] = 2
5. println(m.len) // 返回2
6. }

in操作符

判断某一个元素是否包含在map的key中

1. fn main() {
2. mut m := map[string]int{}
3. m['one'] = 1
4. m['two'] = 2
5. println('one' in m) //返回true
6. println('three' in m) //返回false
7. }

遍历map

1. fn main() {
2. mut m := map[string]int{}
3. m['one'] = 1
4. m['two'] = 2
5. m['three'] = 3
6. for key, value in m {
7. println('key:$key,value:$value')
8. }
9. for key, _ in m {
10. println('key:$key')
11. }
12. for _, value in m {
13. println('value:$value')
14. }
15. }

访问字典成员错误处理

1. module main

3. fn main() {
4. sm := {
5. 'abc': 'xyz'
6. }
7. val := sm['bad_key']
8. println(val) // 如果字典元素不存在,会返回该类型的默认值:空字符串
9. intm := {
10. 1: 1234
11. 2: 5678
12. }
13. s := intm[3]
14. println(s) // 如果字典元素不存在,会返回该类型的默认值:0
15. //也可以加上or代码块来进行错误处理
16. mm := map[string]int{}
17. val2 := mm['bad_key'] or { panic('key not found') }
18. println(val2)
19. myfn()
20. }

22. fn myfn() ? {
23. mm := map[string]int{}
24. x := mm['bad_key']? //也可以本层级不处理,向上抛转错误
25. println(x)
26. }

if条件语句判断字典成员是否存在

1. fn main() {
2. mut m := {'xy': 5, 'zu': 7}
3. mut res := []int{cap:2}
4. for k in ['jk', 'zu'] {
5. //检查字典m[k]是否存在,如果存在,则赋值,if条件返回true,如果不存在,则返回false
6. if x := m[k] {
7. res << x
8. } else {
9. res << -17
10. }
11. }
12. println(res) //[-17,7]
13. }

字典相关的源代码可以参考v源代码中的：vlib/builtin/map.v

更多字典相关的函数,参考标准库章节