1. /**
    2.     * 接受一个可迭代的参数
    3.     * @param {*} iterable 
    4.     * 正确格式为[[key,value],[key,value]]
    5.     */
    6. const Mymap = (() => {
    7.     // 设置私有属性
    8.     const getObj = Symbol('getObj')
    9.     const arrKey = Symbol('arrKey')
    10.     const isEqual = Symbol('isEqual')
    11.     return class Mymap {
    12.         /**
    13.          * 接受一个可迭代的参数
    14.          * @param {*} iterable 
    15.          * 正确格式为[[key,value],[key,value]]
    16.          */
    17.         constructor(iterable = []) {
    18.             this[arrKey] = []
    19.             // 判断格式是否真确 
    20.             // 正确格式为[[key,value],[key,value]]
    21.             if (typeof iterable[Symbol.iterator] !== 'function') {
    22.                 throw new TypeError(`${iterable} is not an iterator`)
    23.             }
    24.             for (const item of iterable) {
    25.                 //数组内的格式是否正确
    26.                 // 正确格式为[[key,value],[key,value]]
    27.                 if (typeof item[Symbol.iterator] !== 'function') {
    28.                     throw new TypeError(`${item} is not iterator`)
    29.                 }
    30.                 // 将其key与value 值迭代出来
    31.                 const iterator = item[Symbol.iterator]()
    32.                 const key = iterator.next().value;
    33.                 const value = iterator.next().value;
    34.                 this.set(key, value)
    35.             }
    37.         }
    38.         /**
    39.          * 写入key 与 value
    40.          * 当其key重复时 当前key的value会覆盖之前value
    41.          * 若是新key 则添加
    42.          * @param {*} key 
    43.          * @param {*} value 
    44.          */
    45.         set(key, value) {
    46.             const obj = this[getObj](key)
    47.             if (obj) {
    48.                 obj.value = value
    49.             } else {
    50.                 this[arrKey].push({
    51.                     key,
    52.                     value
    53.                 })
    54.             }
    55.         }
    56.         /**
    57.          * 查看是否拥有某个key值
    58.          * @param {*} key 
    59.          * 返回值为 true  or  false
    60.          */
    61.         has(key) {
    62.             return this[getObj](key) !== undefined;
    63.         }
    64.         /**
    65.          * 查看某个一key值得value
    66.          * @param {*} key 
    67.          * 返回值为 value or false
    68.          */
    69.         get(key) {
    70.             const obj = this[getObj](key);
    71.             return obj !== undefined ? obj.value : false
    72.         }
    73.         /**
    74.          * 删除某一个key
    75.          * @param {*} key 
    76.          * 返回值为 true or false
    77.          */
    78.         delete(key) {
    79.             for (let i = 0; i < this[arrKey].length; i++) {
    80.                 let obj = this[arrKey][i]
    81.                 if (obj.key === key) {
    82.                     this[arrKey].splice(i, 1)
    83.                     return true;
    84.                 }
    85.             }
    86.             return false;
    88.         }
    89.         /**
    90.          * 清空
    91.          */
    92.         clear() {
    93.             this[arrKey].length = 0;
    94.         }
    96.         /**
    97.          * 遍历 
    98.          * 与Array的forEach有区别
    99.          * 第一项的值为 value 
    100.          * 第二项的值为 key
    101.          * 第三项的值为 this
    102.          * @param {*} callback 
    103.          */
    104.         forEach(callback) {
    106.             for (const { key, value } of this[arrKey]) {
    107.                 callback(value, key, this)
    108.             }
    109.         }
    110.         /**
    111.          * 获取键值对的数量 与Array的length 一样
    112.          */
    113.         get size() {
    114.             return this[arrKey].length;
    115.         }
    116.         /**
    117.          * 使其成为可迭代对象
    118.          */
    119.         *[Symbol.iterator]() {
    120.             for (const { key, value } of this[arrKey]) {
    121.                 yield [key, value]
    122.             }
    123.         }
    124.         /**
    125.          * 检索key值
    126.          * @param {*} key 
    127.          */
    128.         [getObj](key) {
    129.             for (const item of this[arrKey]) {
    130.                 if (this[isEqual](key, item.key)) {
    131.                     return item;
    132.                 }
    133.             }
    134.             // return false;
    135.         }
    136.         /**
    137.          * 判断两个key值是否相等
    138.          * @param {*} key1 
    139.          * @param {*} key2 
    140.          */
    141.         [isEqual](key1, key2) {
    142.             if (key1 === 0 && key2 === 0) {
    143.                 return true;
    144.             }
    145.             return Object.is(key1, key2)
    146.         }
    147.     }
    148. })()