陣列的方法

總結一下陣列的方法，不足之處還有很多，請大家多多指導

文章有參照  熱愛前端的17號誒 https://www.cnblogs.com/sqh17/p/8529401.html https://www.cnblogs.com/sqh17/p/8529401.html的部分

1、arr.length  修改原陣列的長度 修改了原陣列

// 可以通過length直接修改陣列
let arr = [1,1,2,3,6,8,45];
// 獲取陣列的長度 
// console.log(arr.length) // 7

// arr.length = 10; // 增加陣列的長度
// console.log(arr); // [1, 1, 2, 3, 6, 8, 45, empty × 3]

// arr.length = 2; // 縮短陣列的長度
// console.log(arr); //  [1,1]
 arr.length = 0; // 清空陣列
 console.log(arr) // []

 2、arr.pop () 陣列末尾刪除一個值 並返回刪除的值 修改了原陣列

// 刪除陣列末尾的一個元素，返回刪除的這個元素，修改原陣列
let arr = [1,1,2,3,6,8,45];
console.log(arr.pop()) // 45
console.log(arr) // [1, 1, 2, 3, 6, 8]

3、arr.push() 陣列末尾新增值 並返回陣列的長度 修改了原陣列

// 在陣列的末尾新增零個或者若干個值  修改了原陣列 並返回陣列的長度
let arr = [1,1,2,3,6,8,45];
console.log(arr.push(100,200)) // 8
console.log(arr) // [1, 1, 2, 3, 6, 8, 45, 100, 200]

4、arr.shift() 陣列起始位置刪除一個值 並返回刪除的值 修改了原陣列

// 在陣列的起始位置刪除一個值，並返回刪除的值 修改了原陣列
let arr = [1,1,2,3,6,8,45];
console.log(arr.shift()) // 1
console.log(arr) // [1, 2, 3, 6, 8, 45]

5、arr.unshift() 陣列起始位置新增值 並返回陣列的長度 修改了原陣列

// 在陣列的起始位置新增零個或者若干個值，並返回陣列的長度，修改了原陣列
let arr = [1,1,2,3,6,8,45];
console.log(arr.unshift(5,6)) // 9
console.log(arr) // [5, 6, 1, 1, 2, 3, 6, 8, 45]

6、arr.splice() 陣列元素的替換 修改了原陣列

/*
    splice(start, length, data1, data2...); 修改替換
        start 從第幾位開始替換 可為負數
        length 替換掉幾位
        data1, data2... 要替換進去的資料

    以陣列形式返回被刪除資料 修改原陣列
*/

let arr = [1,1,2,3,6,8,45];

// console.log(arr.splice(1,2,'a','b','c')) // [1, 2]
// console.log(arr) // [1, 'a','b','c', 3, 6, 8, 45]

// 如果不傳要替換的資料 就是指定位刪除
// console.log(arr.splice(2,1)); // [2]
// console.log(arr) // [1, 1, 3, 6, 8, 45]

// 如果刪除的長度為0 就是指定位新增
// console.log(arr.splice(2,0,'A','B','C')); // []
// console.log(arr) // [1, 1, "A", "B", "C", 2, 3, 6, 8, 45]

// 如果開始位數是負數 就從末尾倒數
console.log(arr.splice(2,0,'A','B','C')); // []
console.log(arr) // [1, 1, "C", 2, 3, 6, "A", "B", 8, 45]

7、arr.join() 將陣列連結成字串 返回一個字串 不修改原陣列

// arr.join('分隔符')將陣列連結成字串，用分隔符分開，如果沒有傳分隔符預設用','分開，返回一個字串
let arr = [1,1,2,3,6,8,45];
// console.log(arr.join('-')) // 1-1-2-3-6-8-45

// 未寫分隔符
console.log(arr.join()) // 1,1,2,3,6,8,45

// 注 空陣列
let arr1 = [];
console.log(arr1.join()) // 空的 什麼也不返回

// 只有長度沒有值的陣列
let arr2 = new Array(3)
console.log(arr2.join()) // ,,

8、arr.concat() 將一個或多個陣列合並起來 或者陣列末尾新增新元素 返回一個新陣列 不改變原陣列

// arr.concat() 將陣列合並或者陣列末尾新增值 返回一個新陣列 不改變原陣列
let arr1 = ['a','b','c'];
let arr2 = ['A','B','C'];
let arr3 = [1,2,3];

console.log(arr1.concat(arr2,arr3)) // ["a", "b", "c", "A", "B", "C", 1, 2, 3]
console.log(arr2.concat(arr3,5,89,100)) // ["A", "B", "C", 1, 2, 3, 5, 89, 100]

9、arr.reverse() 將陣列內元素顛倒 返回一個陣列內元素顛倒了的陣列，原陣列內元素也顛倒了 修改了原陣列

// arr.reverse() 將陣列內元素顛倒 返回的陣列元素顛倒 原陣列與返回的陣列一樣 元素顛倒  修改了原陣列

let arr3 = [1,2,3];
let arr4 = arr3.reverse();

console.log(arr3.reverse()); // [3, 2, 1]     [3, 2, 1]
console.log(arr3 === arr4); // true

10、arr.sort() 排序 是根據字典排序  修改了原陣列

/*
    arr.sort()預設排序是字典序
        a 
            aa
                aaa
                aab
            ab
        b
            ba
            bb
*/ 
let arr = [1,25,2,3,55,6,10,1008,45];

// 預設排序
console.log(arr.sort()); // [1, 1008, 2, 25, 3, 45, 55, 6, empty]
console.log(arr) // [1, 1008, 2, 25, 3, 45, 55, 6, empty]

// 尋找一個排序的規律
/*  arr.sort(function(n1, n2){
       console.log(n1,n2);
       return  根據返回的值決定是否交換n1 n2的位置
       大於等於0不換位置
       小於0互換位置
}) */

arr.sort(function(n1,n2){
    // 從大到小排序
    // return n2-n1
    // 從小到大
     return n1-n2
})
console.log(arr) // [1, 2, 3, 6, 10, 25, 45, 55, 1008]

// 自定義排序 如要如下陣列從大到小排序
let arr1=['十','一','三','五','九','八','零','六','七'];
        let sortNum = {
            零: 0,
            一: 1,
            三: 3,
            五: 5,
            六: 6,
            七: 7,
            八: 8,
            九: 9,
            十: 10
        }
        console.log(sortNum['一']); // 1
        console.log(sortNum['十']); // 10

        arr1.sort(function(n1, n2){
            return sortNum[n2]-sortNum[n1]
        })
        console.log(arr1) // ["十", "九", "八", "七", "六", "五", "三", "一", "零"]

11、arr.forEach() 遍歷陣列中的每一位 不修改原陣列

        // forEach陣列的迴圈遍歷 迴圈陣列中的每一位 不修改原陣列
        let arr = ["a","b","c","d","e"];
        /*
            arr.forEach(function(item,index, array){
                console.log(item, index);
                // item 陣列中這一位的值
                // index 陣列中這一位的索引
                // array 是原陣列
            })
        */
        let arr2 = []
        arr.forEach(function(item,index){
                console.log(item, index);
                arr2.push(item.toUpperCase())
        })
        console.log(arr,arr2) // ["a", "b", "c", "d", "e"]   ["A", "B", "C", "D", "E"]

12、arr.map() 替換  返回一個替換後的新陣列 不修改原陣列

/*
    不改變原陣列
    arr.map(function(item, index, array){ // 根據arr的每一位生成一個新的陣列 array 是原陣列
        return 一個要生成的新陣列
    }) 
    map 的返回值是一個替換後的陣列
*/
let arr = ["a","b","c","d","e"];
let arr2 = arr.map(function(item, index){
    console.log(item, index);
    return item.toUpperCase()
})
console.log(arr, arr2) // ["a", "b", "c", "d", "e"]  ["A", "B", "C", "D", "E"]

forEach和map的區別

1、forEach()和for迴圈一樣，map()是修改陣列中的資料，並返回新的陣列

2、forEach()沒有return，而map()必須要有return

13、arr.filter()  過濾陣列 返回值是一個過濾後的新陣列  不修改原陣列

/*
    不修改原陣列
    arr.filter(function(item, index){ // 對陣列進行過濾
        return true 保留這這個元素 false 過濾掉這個元素
    }) 
*/
let arr = [1,25,2,3,55,6,10,1008,45];
let arr2 = arr.filter(function(item, index){
    console.log(item, index);
    return item>10
})
console.log(arr, arr2) // [1, 25, 2, 3, 55, 6, 10, 1008, 45]  [25, 55, 1008, 45]

14、arr.every() 陣列中的資料是否全都滿足條件語句的值 返回true | false  不修改原陣列

/*
    不修改原陣列
    arr.every(function(item, index){
        console.log(item,index) // 有不滿足條件的就不執行了 返回false
        return 條件語句
    })
    陣列中的資料是否全都滿足條件語句 有不滿足的就返回false 全部滿足則返回true 
*/
let arr = [1,25,2,3,55,6,10,1008,45];
let arr2 = arr.every(function(item, index){
    console.log(item, index);
    return item>10
})
console.log(arr, arr2) // [1,25,2,3,55,6,10,1008,45] false

15、arr.some() 陣列中的資料是否有滿足條件語句的值 返回true | false  不修改原陣列

/*
    不修改原陣列
    arr.some(function(item, index){
        console.log(item,index)  // 有滿足條件的就不執行了 返回true
        return 條件語句
    })
    陣列中的資料是否有滿足條件語句 
    有一項滿足的就返回true 全部不滿足則返回false
*/
let arr = [1,25,2,3,55,6,10,1008,45];
let arr2 = arr.some(function(item, index){
    console.log(item, index); 
    return item>10
})
console.log(arr, arr2) // [1,25,2,3,55,6,10,1008,45] true

16、arr.reduce() 不修改原陣列

/*
    不修改原陣列  
    arr.reduce(function(n1, n2){
        console.log(n1,n2)
        return n1+n2
    },a)

    如果a不傳值
    第0次執行：預設傳入 n1: 第0位 n2: 第一位
    第1次執行：傳入 n1：第0次執行的返回值(如果沒有return 就是undefined) n2: 第2位
    第2次執行：傳入 n1：第1次執行的返回值(如果沒有return 就是undefined) n2: 第3位
    ...

    如果a傳值 第0次執行 預設傳入n1 就是a的值 依次類推

    最終reduce 返回值是最後一次的返回值
    如果arr是空陣列 會報錯 解決辦法就是傳入a值(隨便傳，不要影響計算結果就好)
*/
let arr = [11,9,2,3,55,6,10,1008,45];
let arr2 = arr.reduce(function(n1, n2){
    console.log(n1, n2);
    return n1+n2
    // return item>10
})
console.log(arr, arr2) // [11, 9, 2, 3, 55, 6, 10, 1008, 45]  1149

let arr = [11,9,2,3,55,6,10,1008,45];

// 用reduce() 找陣列的最大值
let arr2 = arr.reduce(function(n1, n2){
    console.log(n1, n2);
    // return n1 > n2? n1 : n2
    return Math.max(n1, n2)
})
console.log(arr2) // 1008

// 用reduce() 找陣列的最小值
let arr3 = arr.reduce(function(n1, n2){
    console.log(n1, n2);
    // return n1 > n2? n1 : n2
    return Math.min(n1, n2)
})
console.log(arr3) // 2


// 用reduce給陣列去重
let dou = [11,9,11,3,55,6,9,1008,3,7,7];
let arr4 = dou.reduce(function(n1, n2){
    if(!Array.isArray(n1)){
        n1[0] = n1
    }

    return n1.includes(n2)? n1 : n1.concat(n2)
})
console.log(arr4) // [11, 9, 3, 55, 6, 1008, 7]

// 將陣列扁平化 一維化
let flat = [[100,99],1,2,[3,4],[5,[6,7,[8,9,[10,11],12]]],13]

function newArr(arr){
    return arr.reduce(function(item1, item2){
        if(Array.isArray(item2)){
            return item1.concat(newArr(item2))
        }else{
            return item1.concat(item2)
        }
    },[])
}
console.log(newArr(flat)) // [100, 99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]


// 計算陣列中每個元素出現的次數
 let duc = ['nn','aa','ad','nn', 'aa', 'aa','df','ad','nn'];
 let arr6 = duc.reduce(function(n1,n2){
    if(n2 in n1){
        n1[n2]++
    }else{
        n1[n2] = 1
    }
    return n1
 },{})

console.log(arr6) // {nn: 3, aa: 3, ad: 2, df: 1}

還有一個reduceRight()與reduce()功能用法一樣，不同點是前者是從陣列末尾向前開始進行計算的

 17、arr.slice() 切割陣列 以陣列形式返回切割下來的值 不修改原陣列

/*
    arr.slice(start, end) 切割陣列
    start 切割開始的位置(若為負數則不切割)
    end   切割結束的位置 不包含這個位置的值(若為負數則從後向前數, 若不傳則會切割從start開始往後的所有值)

    不修改原陣列  並以陣列的形式返回切割下的值
*/

let arr = [11,9,2,3,55,6,10,1008,45]
// console.log(arr.slice(2,5), arr) // [2, 3, 55] [11, 9, 2, 3, 55, 6, 10, 1008, 45]
// console.log(arr.slice(6)) // [10, 1008, 45]
console.log(arr.slice(2,-3)) // [2, 3, 55, 6]

此外陣列能用的方法中還有 arr.indexOf()    arr.lastIndexOf()

與字串的用法一樣

18、Array.from(arr) 將類陣列arr 轉換成陣列  不改變原來的類陣列

/*
    Array.from(類屬組, callBack, this指向)
    把類屬組轉化成真正的陣列
        類屬組: 要轉化的類屬組
        callBack： 不定參可用可不用，把陣列遍歷一遍，有兩個引數分別對應陣列當前項和下標
        this指向： 不定參 繫結this的指向
    不改變原類屬組
*/

// 模擬一個類陣列 轉化成陣列
let data = {
    0: 12,
    1: 3,
    2: 5,
    3: 7,
    length: 4
}
// console.log(Array.from(data)) // [12, 3, 5, 7]

let arr1 = Array.from(data,function(item, index){
    console.log(item, index, this);
    return item+item
},document)
console.log(arr1) // [24, 6, 10, 14]

// 監測是一個物件還是一個陣列
console.log(Object.prototype.toString.call(arr1)) // [object Array]
console.log(Object.prototype.toString.call(data)) // [object Object]

19、Array.isArray(arr) 判斷一個變數是不是陣列  類陣列不是陣列

<body>
    <ul id="list">
        <li>li1</li>
        <li>li2</li>
        <li>li3</li>
        <li>li4</li>
        <li>li5</li>
    </ul>
    <script>
        // 類陣列不是陣列，在Array.isArray(arr)的判斷中是false
        // arr是要檢測的變數
        // 返回值true | false
        let arr = ["a","b","c","d","e"];
        let ul = document.getElementById('list');
        let li = ul.querySelectorAll('li'); // 這個li是類陣列
        console.log(Array.isArray(li))     // false
        console.log(Array.isArray(arr))    // true

    </script>
</body>

20、Array.of(data1,data2...) 將引數轉化成一個陣列 也可用作生成陣列 返回一個新陣列

/*
    Array.of(data1,data2...) 將引數轉化成陣列
        data: 要放入陣列中的值
        返回一個新的陣列 如果引數為空則返回一個空陣列
*/
let arr = Array.of(1,2,3,4,5);
console.log(arr) // [1, 2, 3, 4, 5]

21、arr.find() 查詢陣列中滿足要求的第一個元素

/*
    Array.find(callBack, this指向) 查詢陣列中滿足要求的第一個元素的值
        callBack接收三個引數
            遍歷到的元素
            遍歷到元素的下標
            陣列本身
        this指向：繫結this指向
    返回陣列中第一個滿足要求的值，否則返回undefined
*/
let arr = [11,9,2,3,55,6,10,1008,45];
let arr2 = arr.find(function(el,idx){
    return el>20
    // return el>2000  // undefined
},document);
console.log(arr, arr2) // [11, 9, 2, 3, 55, 6, 10, 1008, 45] 55

22、arr.findIndex() 查詢陣列中滿足要求的第一個元素的索引值

/*
    Array.findIndex(callBack, this指向) 查詢陣列中滿足要求的第一個元素的下標
        callBack接收三個引數
            遍歷到的元素
            遍歷到元素的下標
            陣列本身
        this指向：繫結this指向
    返回值：一個包含將陣列與子陣列中所有元素的新陣列
*/
let arr = [11,9,2,3,55,6,10,1008,45];
let arr2 = arr.findIndex(function(el,idx){
    return el>20
    // return el>2000 // -1
},document);
console.log(arr, arr2) // [11, 9, 2, 3, 55, 6, 10, 1008, 45] 55

23、arr.flat() 扁平化多維陣列

/*
    arr.flat(deep) 將陣列扁平化 將將多維陣列轉換成一維陣列
        deep: 可選引數 
        預設是1 就是提取一層
        不知道有多少層  可用Infinity 無限層直接轉換成一維
    不改變原陣列    
*/
let flat = [[100,99],1,2,[3,4],[5,[6,7,[8,9,[10,11],12]]],13]
console.log(flat.flat(Infinity)) // [100, 99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

24、arr.flatMap()用遍歷的方法陣列扁平化 不過只能提取一層

/*
    arr.flatMap(callBack, thisArg) 方法首先使用對映函式對映每個元素，然後將結果壓縮成一個新陣列。它與 map 和 深度值1的 flat 幾乎相同，但 flatMap 通常在合併成一種方法的效率稍微高一些
        callBack有三個引數：
            callBack接收三個引數
            遍歷到的元素
            遍歷到元素的下標
            陣列本身
        this指向：繫結this指向
        預設是1 就是提取一層
        不知道有多少層  可用Infinity 無限層直接轉換成一維
    不改變原陣列    
*/
let arr = [[100,99],1,2,[3,4],[5,[6,7,[8,9,[10,11],12]]],13];

let arr1 = arr.flatMap(function(item, index){
    return item
},document)
console.log(arr1) //  [100, 99, 1, 2, 3, 4, 5, Array(3), 13]

25、arr.fill() 填充指定位置的陣列 改變原陣列

/*
    arr.fill(data, start, end);用一個固定值填充一個陣列中從起始索引到終止索引的內的全部元素，不包括終止索引。相當於替換 不改變原始陣列的長度
        data: 要填充的值
        可選引數
            start： 起始索引
            end： 終止索引，預設值為arr.length 
    返回一個新的陣列  修改原陣列  
*/
let arr = [11,9,2,3,55,6,10,1008,45];

// let arr1 = arr.fill('a',2, 5)
// console.log(arr1 , arr) //  [11, 9, "a", "a", "a", 6, 10, 1008, 45]   [11, 9, "a", "a", "a", 6, 10, 1008, 45]

// 當什麼引數都不傳時
/* let arr2 = arr.fill()
console.log(arr2) // [undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined] */

// 當直傳一個填充引數時
/* let arr2 = arr.fill('A')
console.log(arr2) // ["A", "A", "A", "A", "A", "A", "A", "A", "A"] */

// 當穿兩個引數時
let arr2 = arr.fill('A', 5)
console.log(arr2) // [11, 9, 2, 3, 55, "A", "A", "A", "A"]

26、arr.includes() 判斷陣列中是否包含一個指定的值

/*
    arr.includdes(val, index)判斷陣列中是否包含一個指定的值
        val：需要查詢的值
        index: 可選引數 從下標為index的位置開始查
    返回一個Boolean的值  true | false  
*/
let arr = ["a","b","c","d","e"];

console.log(arr.includes('c')) // true
console.log(arr.includes('c',3)) // false
console.log(arr.includes('c',-3)) // true 從後往前數3位再從這三位裡找有沒有 'c'

27、arr.copyWithin() 在當前陣列內部，將陣列指定位置的值放到其他位置，並覆蓋原陣列值，返回一個新的陣列，改變原陣列

/*
    arr.copyWithin(target, start, end)方法淺複製陣列的一部分到同一陣列中的另一個位置，並返回它，                    
     不會改變原陣列的長度定的值
        target：0 為基底的索引，複製序列到該位置。
                如果是負數，target 將從末尾開始計算。
                如果 target 大於等於 arr.length，將會不發生拷貝。
                如果 target 在 start 之後，複製的序列將被修改以符合 arr.length。

        start: 0 為基底的索引，開始複製元素的起始位置,
                如果是負數，start 將從末尾開始計算。
                如果 start 被忽略，copyWithin 將會從0開始複製

        end:0 為基底的索引，開始複製元素的結束位置。
            copyWithin 將會拷貝到該位置，但不包括 end 這個位置的元素。
            如果是負數， end 將從末尾開始計算.
            如果 end 被忽略，copyWithin 方法將會一直複製至陣列結尾（預設為 arr.length）。
    修改了原陣列
*/
let arr = ["a","b","c","d","e"];

// console.log(arr.copyWithin()) // ["a", "b", "c", "d", "e"]
// console.log(arr.copyWithin(1,2,3),arr) // ["a", "c", "c", "d", "e"]  ["a", "c", "c", "d", "e"]
// console.log(arr.copyWithin(1)) // ["a", "a", "b", "c", "d"]
console.log(arr.copyWithin(1,3)) // ["a", "d", "e", "d", "e"]

28、arr.keys() 遍歷陣列的鍵名

/*
    arr.keys()返回一個包含陣列中每一個索引鍵的 Array Iterator物件
    返回值 一個新的Array迭代器物件
*/
let arr = ["a","b","c","d","e"];
let arr1 = arr.keys();
console.log(arr1) // Array Iterator迭代器物件
for(let key of arr1){
    console.log(key, arr1[key]) // 0,undefined 1,undefined 2,undefined...
}

29、arr.values() 遍歷陣列的鍵值

/*
    arr.values()返回一個包含陣列中每一個索引值的 Array Iterator物件
    返回值 一個新的Array迭代器物件 包含陣列每個索引對應的值
*/
let arr = ["a","b","c","d","e"];
let arr1 = arr.values();
console.log(arr1) // Array Iterator迭代器物件
for(let key of arr1){
    console.log(key, arr1[key]) // a,undefined b,undefined c,undefined...
}

30、arr.entries() 遍歷陣列的鍵名和鍵值

/*
    arr.entries()返回一個包含陣列中每一個索引值/值對的 Array Iterator物件
    返回值 一個新的Array迭代器物件 包含陣列每個索引與其對應的值
*/
let arr = ["a","b","c","d","e"];
let arr1 = arr.entries();
console.log(arr1) // Array Iterator迭代器物件
for(let key of arr1){
    console.log(key) // [0,'a'] [1,'b'] [2,'c'] [3,'d'] [4,'e']
}

31、 new Set(arr) 可以儲存任何型別的唯一值包括陣列不修改原陣列

/*
    new Set(arr)  可以儲存任何型別的唯一值包括陣列
    其本身也是一個建構函式  會自動去重
    傳遞的是陣列時 返回的不是陣列 而是有size長度的物件
*/
let arr = ["b","c","d","e", 'b','d','f'];
let mySet = new Set(arr);
console.log(mySet) // {"b", "c", "d", "e", "f"}
// 轉換成陣列
// console.log(Array.from(mySet)) // ["b", "c", "d", "e", "f"]
// 或者用解構賦值轉換成陣列
// console.log([...mySet]) // ["b", "c", "d", "e", "f"]
console.log(mySet.size) // 5
/*
    mySet.size 獲取物件中值的個數
    mySet.add('n') 在set物件末尾新增一個元素，返回該set物件
    mySet.clear() 移出set物件內所有元素
    mySet.delete(val) 移出set中val這個元素，如果這個元素在則返回true 不在沒有刪除成功則返回false
    mySet.entries() 返回一個新的迭代器物件，
        該物件包含Set物件中的按插入順序排列的所有元素的值的[value, value]陣列。
        為了使這個方法和Map物件保持相似， 每個值的鍵和值相等。
    mySet.has(val) set 中是否包含val 返回值為true | false
*/

32、new Map(arr) 接收的不能是一維陣列 要以key value形式

/*
    new Map(arr)  物件儲存鍵值對，並且能夠記住鍵的原始插入順序。
    任何值(物件或者原始值) 都可以作為一個鍵或一個值。
    傳遞的是陣列時 返回的不是陣列 而是有size長度的物件
*/
// let arr = [[100,99],1,2,[3,4],[5,[6,7,[8,9,[10,11],12]]],13];
// let arr = ["b","c","d","e", 'b','d','f'];
let myMap = new Map([['xiaohua','aa'],['xiaohong','bb'],['xiaolan','dd']]);
console.log(myMap) // Map(3) {"xiaohua" => "aa", "xiaohong" => "bb", "xiaolan" => "dd"}
console.log(myMap.size) // 3
// console.log(myMap.delete('xiaohong')) // true
// console.log(myMap.delete('bb')) // false
/*
    myMap.size 獲取物件中值的個數
    myMap.set(key,val) 在map物件末尾新增一個元素，返回該map物件
    myMap.get(key) 返回鍵對應的值，如果不存在，則返回undefined。
    myMap.clear() 移出map物件內所有元素
    myMap.delete(key) 這裡傳的是key而不是value移出map中key這個元素，如果這個元素在則返回true 不在沒有刪除成功則返回false
    myMap.entries() 返回一個新的 Iterator 物件，它按插入順序包含了Map物件中每個元素的 [key, value] 陣列。
    myMap.has(key) map 中是否包含key 返回值為true | false
*/