字典又称关联数组，映射，是一个抽象的数据结构，它包含着类似的键值有序对

    字典是一种以键值对形式存储的数据结构
    特点是

    1. 非线性存储结构
    2. 字典中的元素是可变的，不是必须的，键值是不重复的
    3. 键值是可hash的

    手写字典类

    1. class Dict {
    2.     constructor() {
    3.         this.data = {}
    4.         this.count = 0
    5.     }
    7.     add(key, value) {
    8.         if (!this.data[key]) {
    9.             this.count++
    10.         }
    11.         this.data[key] = value;
    13.         return true;
    14.     }
    16.     remove(key) {
    17.         if (this.data[key]) {
    18.             delete this.data[key]
    19.             this.count--
    20.         }
    21.         return true
    22.     }   
    24.     update(key, newVal) {
    25.         if (this.data[key]) {
    26.             this.data[key] = newVal;
    27.         } else {
    28.             this.add(key, newVal)
    29.         }
    30.     }
    32.     find(key) {
    33.         return this.data[key]
    34.     }
    36.     showAll() {
    37.         Object.keys(this.data).forEach(key =>  console.log(`${key}: ${this.data[key]}`))
    38.     }
    40.     total() {
    41.         return this.count
    42.     }
    44.     clear() {
    45.         this.data = {}
    46.         this.count = 0
    47.     }
    49.     has(key) {
    50.         return !!this.data[key] 
    51.     }
    53.     sort() {
    54.         let result = {}
    55.         Object.keys(this.data).sort().forEach(key =>  {
    56.             result[key] = this.data[key]
    57.         })
    58.         this.data = result
    59.     }
    60. }
    62. // 实例化一个字典类
    63. const dic = new Dict(); 
    65. // 添加书籍和作者
    66. dic.add('书3', '作家3'); 
    67. dic.add('书4', '作家4');
    68. dic.add('书2', '作家2');
    69. dic.add('书1', '作家1');
    70. dic.add('书1', '作家2');
    71. /*
    72. 显示全部
    73. 结果为：
    74.   书3 --> 作家3
    75.   书4 --> 作家4
    76.   书2 --> 作家2
    77.   书1 --> 作家2
    78. */
    79. dic.showAll(); 
    81. // 打印字典元素总数  4
    82. console.log(dic.total())
    83. // 将字典排序
    84. dic.sort();
    85. dic.showAll();
    86. /*
    87. 将排序后的字典输出
    88. 结果为：
    89. 书1 --> 作家2
    90. 书2 --> 作家2
    91. 书3 --> 作家3
    92. 书4 --> 作家4
    93. */
    95. // 删除第四本书
    96. dic.remove('书4')
    97. // 打印字典元素总数  3
    98. console.log(dic.total())

    JS中的字典结构

    1. Object 是 键值对集合，但只能用字符串当做键
    2. Map提供一种完善的Hash结构，可以适用对象当键存储数据
      1. set/get/has/size/delete/clear
      2. keys/values/entries/forEach
      3. 键值可以hash ```javascript let map = new Map()

    let a = {} let b = {}

    map.set(a, 1) map.set(b, 2) console.log(map) // Map { {} => 1, {} => 2 }

    最后的输出值我们可以看到是有两个值，也就是说，我们 map 中对应的 a、b 的 key 值存储的是他们的哈希地址，并不是 {} 这个空对象。所以在 map 中才会有两个值存在

    2. 3. WeakMap
    3.    1. 只接受对象作为键，不包括null, 不接受其他类型的值为键
    4.    1. 不可遍历
    5.    1. 无法清空
    6.    1. 所引用的对象都是弱引用，垃圾回收是不将此引用考虑进去的
    8. <a name="XU10R"></a>
    9. ## 小结
    11. 1. 字典的特点和实现方式
    12. 1. js中的字典实现方式
    13. 1. Map 和 WeakMap的不同
    15. <a name="RWpIR"></a>
    16. ## 练习题
    17. **统计所有小于非负整数 _n_ 的质数的数量。**<br />**<br />例如：输入10<br />输出：4<br />解释：小于 10 的质数一共有 4 个  2、3、5、7
    19. ```javascript
    20. function count(n) {
    21.     if (n <= 2) return 0;
    22.   let result = new Array(n).fill(1)
    23.   result[0] = 0
    24.   result[1] = 0
    25.   let count = 0;
    26.   for (let i = 2; i < n; i++) {
    27.       if (result[i] === 1) {
    28.         count+=1
    29.     }
    30.     for (let j = 2; i * j < n; j++) {
    31.         result[i * j] = 0
    32.     }
    33.   }
    34.   return count
    35. }