JavaScript引用類型---Array

1、建立Array對象實例

let array1 = [1,2,3,4];
    //構造函數
    let array2 = new Array(1,2,3,4); //[1,2,3,4]
    let array3 = new Array(4); // [,,,]
    return(array3);

2、Array實例屬性

Array.prototype靜態屬性

    表示 Array 構造函數的原型，並容許您向全部Array對象添加新的屬性和方法；不爲人知的事實：Array.prototype 自己也是一個 Array

length屬性返回或設置一個數組中的元素個數

/**
     * length屬性：返回或設置一個數組中的元素個數；
     * 該值是一個無符號 32-bit 整數，而且老是大於數組最高項的下標
     */
    let array = ['shoes', 'shirts', 'socks', 'sweaters'];
    return array.length; // 4

3、Array類方法

1.Array.from()從一個相似數組或可迭代對象中建立一個新的數組實例

/**
     * Array.from() 方法從一個相似數組或可迭代對象中建立一個新的數組實例
     * Array.from(arrayLike[, mapFn[, thisArg]])
     *
     * arrayLike  想要轉換成數組的僞數組對象或可迭代對象
     * mapFn (可選參數)  若是指定了該參數，新數組中的每一個元素會執行該回調函數
     * thisArg (可選參數)  可選參數，執行回調函數 mapFn 時 this 對象
     */
    let array1 = Array.from('foo');// ["f", "o", "o"]
    let m = new Map([[1, 2], [2, 4], [4, 8]]);
    let array2 = Array.from(m);// [[1, 2], [2, 4], [4, 8]]
    let array3 = Array.from([1, 2, 3], x => x + x);// [2,4,6]
    function combine(){
        let arr = [].concat.apply([], arguments);  //沒有去重複的新數組
        return Array.from(new Set(arr));
    }
    let x = [1, 2, 2], y = [2,3,3];
    let array4 = combine(x,y);// [1, 2, 3]
    return JSON.stringify(array4);

2.Array.isArray()判斷傳遞的值是不是一個數組

/**
     * Array.isArray() 用於肯定傳遞的值是不是一個 Array
     * Array.isArray(obj)
     *
     * obj   須要檢測的值
     * 若是對象是 Array，則爲true; 不然爲false
     */
    Array.isArray([]); //true
    Array.isArray({}); //false
    Array.isArray(new Array());//true
    Array.isArray(null); //false
    Array.isArray(undefined); //false
    Array.isArray(17); //false
    Array.isArray('Array'); //false
    Array.isArray(true);//false
    Array.isArray(false); //false
    Array.isArray(Array.prototype);// true

3.Array.of()方法建立一個新數組實例，而不考慮參數的數量或類型

/**
     * Array.of() 方法建立一個具備可變數量參數的新數組實例，而不考慮參數的數量或類型
     * Array.of(element0[, element1[, ...[, elementN]]])
     *
     * elementN  任意個參數，將按順序成爲返回數組中的元素
     * 返回值：新的 Array 實例
     */
    let array1 = Array.of(1);         // [1]
    let array2 = Array.of(1, 2, 3);   // [1,2,3]
    let array3 = Array.of(undefined); // [undefined]
    let array4 = Array.of(7);       // [7]
    let array5 = Array(7);          // [ , , , , , , ]
    return JSON.stringify(array5);

4、Array實例方法

1.copyWithin()淺複製數組的一部分到同一數組中的另外一個位置並返回它，而不修改其大小，會更改原數組

/**
     * 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 array1 = [1, 2, 3, 4, 5].copyWithin(-2);// [1, 2, 3, 1, 2]
    let array2 = [1, 2, 3, 4, 5].copyWithin(0, 3);// [4, 5, 3, 4, 5]
    let array3 = [1, 2, 3, 4, 5].copyWithin(0, 3, 4);// [4, 2, 3, 4, 5]
    let array4 = [1, 2, 3, 4, 5].copyWithin(-2, -3, -1);// [1, 2, 3, 3, 4]
    let array5 = [].copyWithin.call({length: 5, 3: 1}, 0, 3);// {"0":1,"3":1,"length":5}
    let array6 = Array.from({length: 5, 3: 1}).copyWithin(0,3);// [1,null,null,1,null]

2.fill()方法用一個固定值填充一個數組中從起始索引到終止索引內的所有元素，會更改原數組

/**
     * fill() 方法用一個固定值填充一個數組中從起始索引到終止索引內的所有元素
     * arr.fill(value[, start[, end]])    [start,end)
     *
     * value   用來填充數組元素的值
     * start   可選，起始索引，默認值爲0
     * end   可選，終止索引，默認值爲 this.length
     *
     * 返回值：修改後的數組，會改變原數組
     */
    [1,2,3].fill(4); // [4,4,4]
    [1,2,3].fill(4,1); //[1,4,4]
    [1,2,3].fill(4,1,2); //[1,4,3]
    [1,2,3].fill(4,1,1); //[1,2,3]
    [1,2,3].fill(4,-3,-2); //[4,2,3]
    [].fill({length:3},4); //{0: 4, 1: 4, 2: 4, length: 3}
    let arr = Array(3).fill({}) // [{}, {}, {}];
    arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]
    return JSON.stringify(arr);

3.concat()用於合併兩個或多個數組，不會更改原數組

/**
     * concat() 方法用於合併兩個或多個數組。此方法不會更改現有數組，而是返回一個新數組
     * var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
     *
     * valueN  將數組和/或值鏈接成新數組
     */
    let array1 = ['a', 'b', 'c'];
    let array2 = [1, 2, 3];
    return array1.concat(array2);// ['a', 'b', 'c', 1, 2, 3]

    let num1 = [[1]];
    let num2 = [2, [3]];
    let nums = num1.concat(num2);
    return JSON.stringify(nums);// [[1], 2, [3]]

4.join()方法將一個數組（或一個類數組對象）的全部元素鏈接成一個字符串並返回這個字符串,不會更改原數組

/**
     * join() 方法將一個數組（或一個類數組對象）的全部元素鏈接成一個字符串並返回這個字符串
     * str = arr.join(separator)
     * separator   指定一個字符串來分隔數組的每一個元素。默認爲 ","
     * 若是須要(separator)，將分隔符轉換爲字符串
     * 若是separator是空字符串("")，則全部元素之間都沒有任何字符
     *
     * 返回值：一個全部數組元素鏈接的字符串。若是 arr.length 爲0，則返回空字符串
     */
    let array = ['Wind', 'Rain', 'Fire'];
    let myVar1 = array.join();      // myVar1的值變爲"Wind,Rain,Fire"
    let myVar2 = array.join(', ');  // myVar2的值變爲"Wind, Rain, Fire"
    let myVar3 = array.join(' + '); // myVar3的值變爲"Wind + Rain + Fire"
    let myVar4 = array.join('');    // myVar4的值變爲"WindRainFire"

5.slice()返回一個從開始到結束（不包括結束）選擇的數組的一部分淺拷貝到一個新數組對象。不會更改原數組

/**
     * slice() 方法返回一個從開始到結束（不包括結束）選擇的數組的一部分淺拷貝到一個新數組對象。且原始數組不會被修改
     * arr.slice(begin, end);
     *
     * begin 可選,從該索引處開始提取原數組中的元素（從0開始）;默認值爲0
     * 若是該參數爲負數，則表示從原數組中的倒數第幾個元素開始提取，slice(-2)表示提取原數組中的倒數第二個元素到最後一個元素（包含最後一個元素）
     * end可選，默認值爲數組的長度；slice會提取原數組中索引從 begin 到 end 的全部元素（包含begin，但不包含end）
     * slice(1,4) 提取原數組中的第二個元素開始直到第四個元素的全部元素 （索引爲 1, 2, 3的元素）
     * 若是該參數爲負數， 則它表示在原數組中的倒數第幾個元素結束抽取；若是 end 大於數組長度，slice 也會一直提取到原數組末尾；
     * slice(-2,-1)表示抽取了原數組中的倒數第二個元素到最後一個元素（不包含最後一個元素，也就是隻有倒數第二個元素）
     *
     * 返回值：一個含有提取元素的新數組
     */
    let fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
    let citrus = fruits.slice(1, 3); //['Orange','Lemon']

6.splice()方法經過刪除現有元素或添加新元素來更改一個數組的內容，會更改原數組

/**
     * splice() 方法經過刪除現有元素或添加新元素來更改一個數組的內容
     * array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
     * start​  指定修改的開始位置（從0計數）
        若是超出了數組的長度，則從數組末尾開始添加內容；
        若是是負值，則表示從數組末位開始的第幾位（從-1計數）；
        若只使用start參數而不使用deleteCount、item，如：array.splice(start) ，表示刪除[start，end]的元素
     * deleteCount  可選,整數，表示要移除的數組元素的個數。
        若是 deleteCount 是 0，則不移除元素。這種狀況下，至少應添加一個新元素。
        若是 deleteCount 大於start 以後的元素的總數，則從 start 後面的元素都將被刪除（含第 start 位）
        若是deleteCount被省略，則其至關於(arr.length - start)
     * item1, item2, ...  可選,要添加進數組的元素,從start 位置開始
        若是不指定，則 splice() 將只刪除數組元素
     *
     * 返回值：由被刪除的元素組成的一個數組，若是沒有刪除元素，則返回空數組
     */
    let myFish = ["angel", "clown", "mandarin", "surgeon"];
    let removed = myFish.splice(2, 0, "drum");
    console.log(myFish); //["angel", "clown", "drum", "mandarin", "surgeon"]
    console.log(removed); //[]

7.push()方法將一個或多個元素添加到數組的末尾，並返回新數組的長度

/**
     * push() 方法將一個或多個元素添加到數組的末尾，並返回新數組的長度
     * arr.push(element1, ..., elementN)
     * elementN  被添加到數組末尾的元素
     *
     * 返回值：當調用該方法時，新的 length 屬性值將被返回
     */
    let sports = ["soccer", "baseball"];
    let total = sports.push("football", "swimming");
    console.log(sports);// ["soccer", "baseball", "football", "swimming"]
    console.log(total);// 4

8.pop()方法從數組中刪除最後一個元素，並返回該元素的值。此方法更改數組的長度

/**
     * pop()方法從數組中刪除最後一個元素，並返回該元素的值。此方法更改數組的長度
     * arr.pop()
     *
     * 返回值：從數組中刪除的元素(當數組爲空時返回undefined)
     */
    let myFish = ["angel", "clown", "mandarin", "surgeon"];
    let popped = myFish.pop();
    console.log(myFish);// ["angel", "clown", "mandarin"]
    console.log(popped);// surgeon

9.unshift()方法將一個或多個元素添加到數組的開頭，並返回新數組的長度

/**
     * unshift() 方法將一個或多個元素添加到數組的開頭，並返回新數組的長度
     * arr.unshift(element1, ..., elementN)
     *
     * element1, ..., elementN   要添加到數組開頭的元素
     * 返回值：當一個對象調用該方法時，返回其 length 屬性值
     */
    let array = [1, 2];
    let length1 = array.unshift(0);
    console.log(length1); //3
    console.log(array); //[0, 1, 2]
    let length2 = array.unshift(-2, -1);
    console.log(length2); //5
    console.log(array); //[-2, -1, 0, 1, 2]
    let length3 = array.unshift( [-3] );
    console.log(length3); //6
    console.log(array); //[[-3], -2, -1, 0, 1, 2]

10.shift()方法從數組中刪除第一個元素，並返回該元素的值。此方法更改數組的長度

/**
     * shift() 方法從數組中刪除第一個元素，並返回該元素的值;此方法更改數組的長度
     * arr.shift()
     *
     * 返回值：從數組中刪除的元素; 若是數組爲空則返回undefined
     */
    let myFish = ['angel', 'clown', 'mandarin', 'surgeon'];
    console.log('調用 shift 以前: ' + myFish);// "調用 shift 以前: angel,clown,mandarin,surgeon"
    let shifted = myFish.shift();
    console.log('調用 shift 以後: ' + myFish);// "調用 shift 以後: clown,mandarin,surgeon"
    console.log('被刪除的元素: ' + shifted);// "被刪除的元素: angel"

11.every()方法測試數組的全部元素是否都經過了指定函數的測試，不會更改原數組

/**
     * every() 方法測試數組的全部元素是否都經過了指定函數的測試
     * arr.every(callback[, thisArg])
     *
     * callback   用來測試每一個元素的函數
     * thisArg   執行 callback 時使用的 this 值
     * every 不會改變原數組
     */
    function isBigEnough(element, index, array) {
        return (element >= 10);
    }
    let array1 = [12, 5, 8, 130, 44];
    let array2 = [12, 54, 18, 130, 44];
    let passed = array1.every(isBigEnough);// passed is false
    passed = array2.every(isBigEnough);// passed is true
    return passed;

12.some()方法測試數組中的某些元素是否經過由提供的函數實現的測試

/**
     * some() 方法測試數組中的某些元素是否經過由提供的函數實現的測試
     * arr.some(callback[, thisArg])
     *
     * callback  用來測試每一個元素的函數，接受三個參數：
        currentValue 數組中正在處理的元素
        index 可選,數組中正在處理的元素的索引值
        array可選,some()被調用的數組
     * thisArg  可選,執行 callback 時使用的 this 值
     *
     * 返回值：若是回調函數返回任何數組元素的truthy值，則返回true；不然爲false
     */
    function isBiggerThan10(element, index, array) {
        return element > 10;
    }
    [2, 5, 8, 1, 4].some(isBiggerThan10);  // false
    [12, 5, 8, 1, 4].some(isBiggerThan10); // true

13.filter()方法建立一個新數組, 其包含經過所提供函數實現的測試的全部元素，不會更改原數組

/**
     * filter() 方法建立一個新數組, 其包含經過所提供函數實現的測試的全部元素
     * let new_array = arr.filter(callback[, thisArg])
     *
     * callback  用來測試數組的每一個元素的函數。
     * 調用時使用參數 (element, index, array),返回true表示保留該元素（經過測試），false則不保留
     * thisArg  可選，執行 callback 時的用於 this 的值
     *
     * 返回值：一個新的經過測試的元素的集合的數組；filter 不會改變原數組
     */
    function isBigEnough(element) {
        return element >= 10;
    }
    let filtered = [12, 5, 8, 130, 44].filter(isBigEnough);// filtered is [12, 130, 44]
    filtered = [12, 5, 8, 130, 44].filter(element => element < 10);// filtered is [5,8]
    return (JSON.stringify(filtered));

14.find()方法返回數組中知足提供的測試函數的第一個元素的值。不然返回 undefined，不會更改原數組

/**
     * find() 方法返回數組中知足提供的測試函數的第一個元素的值。不然返回 undefined
     * arr.find(callback[, thisArg])
     *
     * callback  在數組每一項上執行的函數，接收 3 個參數：
     element  當前遍歷到的元素。
     index  當前遍歷到的索引。
     array  數組自己
     * thisArg 可選，指定 callback 的 this 參數
     *
     * 返回值：當某個元素經過 callback 的測試時，返回數組中的一個值，不然返回 undefined
     */
    let inventory = [
        {name: 'apples', quantity: 2},
        {name: 'bananas', quantity: 0},
        {name: 'cherries', quantity: 5}
    ];
    function findCherries(fruit) {
        return fruit.name === 'cherries';
    }
    let hasCherries = inventory.find(findCherries);
    console.log(hasCherries); // { name: 'cherries', quantity: 5 }
    /**
     * 查找質數
     */
    function isPrime(element,index,array) {
        for (let start = 2; start < element; start++) {
            if (element % start === 0){
                return false;
                break;
            }
        }
        return true;
    }
    return([4, 5, 8, 12].find(isPrime)); //5

15.findIndex()方法返回數組中知足提供的測試函數的第一個元素的索引。不然返回-1，不會更改原數組

/**
     * findIndex()方法返回數組中知足提供的測試函數的第一個元素的索引;不然返回-1
     * arr.findIndex(callback[, thisArg])
     *
     * callback  在數組每一項上執行的函數，接收 3 個參數：
     element  當前遍歷到的元素。
     index  當前遍歷到的索引。
     array  數組自己
     * thisArg 可選，指定 callback 的 this 參數
     */
    function isPrime(element,index,array) {
        for (let start = 2; start < element; start++) {
            if (element % start === 0){
                return false;
                break;
            }
        }
        return true;
    }
    return([4, 5, 8, 12].findIndex(isPrime)); //1

16.includes()方法用來判斷一個數組是否包含一個指定的值，若是包含則返回 true，不然返回false

/**
     * includes() 方法用來判斷一個數組是否包含一個指定的值，根據狀況，若是包含則返回 true，不然返回false
     * arr.includes(searchElement, fromIndex)
     *
     * searchElement  須要查找的元素值
     * fromIndex 可選  從該索引處開始查找 searchElement。
     * 若是爲負值，則按升序從 array.length + fromIndex 的索引開始搜索。默認爲 0
     * 若是大於等於數組長度 ，則返回 false,該數組不會被搜索
     *
     * 返回值：一個 Boolean類型
     */
    let array = [1,2,3];
    array.includes(2); //true
    array.includes(4); //false
    array.includes(3,3); //false
    array.includes(3,-1); //true

    (function() {
        console.log([].includes.call(arguments, 'a')); // true
        console.log([].includes.call(arguments, 'd')); // false
    })('a','b','c');

17.indexOf()方法返回在數組中能夠找到一個給定元素的第一個索引，若是不存在，則返回-1。不更改原數組

/**
     * indexOf()方法返回在數組中能夠找到一個給定元素的第一個索引，若是不存在，則返回-1
     * arr.indexOf(searchElement[, fromIndex = 0])
     *
     * searchElement  要查找的元素
     * romIndex  開始查找的位置。其默認值爲0
     * 若是該索引值大於或等於數組長度，意味着不會在數組裏查找，返回-1
     * 若是參數中提供的索引值是一個負值，則被看做是 arr.length + romIndex ,若是抵消後的索引值仍小於0，則整個數組都將會被查詢
     * 注意：若是參數中提供的索引值是一個負值，並不改變其查找順序，查找順序仍然是從前向後查詢數組
     *
     * 返回值：首個被找到的元素在數組中的索引位置; 若沒有找到則返回 -1
     */
    let array = [2, 5, 9];
    array.indexOf(2);     // 0
    array.indexOf(7);     // -1
    array.indexOf(9, 2);  // 2
    array.indexOf(2, -1); // -1
    return array.indexOf(2, -3); // 0

    let indices = [];
    let array = ['a', 'b', 'a', 'c', 'a', 'd'];
    let idx = array.indexOf('a');
    while(idx != -1) {
        indices.push(idx);
        idx = array.indexOf('a',idx + 1);
    }
    return JSON.stringify(indices); // [0, 2, 4]

18.lastIndexOf()方法返回指定元素在數組中的最後一個的索引，從 fromIndex 處開始從後向前查找，若是不存在則返回 -1。不會更改原數組

/**
     * lastIndexOf() 方法返回指定元素在數組中的最後一個的索引，若是不存在則返回 -1。從數組的後面向前查找，從 fromIndex 處開始
     * arr.lastIndexOf(searchElement[, fromIndex = arr.length - 1])
     *
     * searchElement  被查找的元素
     * fromIndex  今後位置開始逆向查找。默認爲數組的長度減 1，即整個數組都被查找。
     * 若是該值大於或等於數組的長度，則整個數組會被查找。若是爲負值，將其視爲從數組末尾向前的偏移。
     * 即便該值爲負，數組仍然會被從後向前查找。若是該值爲負時，其絕對值大於數組長度，則方法返回 -1，即數組不會被查找
     *
     * 返回值：數組中最後一個元素的索引，如未找到返回-1
     */
    let array = [2, 5, 9, 2];
    let index = array.lastIndexOf(2); //3
    index = array.lastIndexOf(7); //-1
    index = array.lastIndexOf(2, 3); //3
    index = array.lastIndexOf(2, 2); //0
    index = array.lastIndexOf(2, -2); //0
    index = array.lastIndexOf(2, -1); //3

    let indices = [];
    let array = ['a', 'b', 'a', 'c', 'a', 'd'];
    let idx = array.lastIndexOf('a'); //4
    while (idx != -1) {
        indices.push(idx);
        idx = (idx > 0 ? array.lastIndexOf('a', idx - 1) : -1);
    }
    console.log(indices); //[4, 2, 0];

19.reduce()方法對累加器和數組中的每一個元素（從左到右）應用一個函數，將其減小爲單個值，不會更改原數組

/**
     * reduce() 方法對累加器和數組中的每一個元素（從左到右）應用一個函數，將其減小爲單個值
     * arr.reduce(callback[, initialValue])
     *
     * callback  執行數組中每一個值的函數，包含四個參數：
        accumulator 累加器累加回調的返回值; 它是上一次調用回調時返回的累積值，或initialValue
        currentValue 數組中正在處理的元素
        currentIndex 可選,數組中正在處理的當前元素的索引,若是提供了initialValue，則索引號爲0，不然爲索引爲1。
        array可選,調用reduce的數組
     * initialValue  可選,用做第一個調用 callback的第一個參數的值
     * 若是沒有提供初始值，則將使用數組中的第一個元素;在沒有初始值的空數組上調用 reduce 將報錯
     *
     * 返回值：函數累計處理的結果
     */
    let sum1 = [0, 1, 2, 3].reduce(function (a, b) {
        return a + b;
    }, 0); //循環4次，值爲6
    let sum2 = [0, 1, 2, 3].reduce(function (a, b) {
        return a + b;
    }); //循環3次，值爲6
    let flattened = [[0, 1], [2, 3], [4, 5]].reduce(
        function(a, b) {
            return a.concat(b);
        });// 循環2次，flattened is [0, 1, 2, 3, 4, 5]

    /**
     * 計算數組中每一個元素的出現次數
     */
    let array = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice'];
    let countNames = array.reduce((allName,value)=>{
        if (allName[value] == undefined) {
            allName[value] = 1;
        }
        else {
            allName[value] += 1;
        }
        return allName;
    },{});
    return(JSON.stringify(countNames));//{"Alice":2,"Bob":1,"Tiff":1,"Bruce":1}

20.reduceRight()方法接受一個函數做爲累加器（accumulator）和數組的每一個值（從右到左）將其減小爲單個值，不會更改原數組

/**
     * reduceRight() 方法接受一個函數做爲累加器（accumulator）和數組的每一個值（從右到左）將其減小爲單個值
     * arr.reduceRight(callback[, initialValue])
     *
     * 返回值：函數累計處理的結果
     */
    let sum1 = [0, 1, 2, 3].reduceRight(function (a, b) {
        return a + b;
    }, 0); //循環4次，值爲6
    let sum2 = [0, 1, 2, 3].reduceRight(function (a, b) {
        return a + b;
    }); //循環3次，值爲6
    let flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(
        function(a, b) {
            return a.concat(b);
        });// 循環2次，flattened is [4,5,2,3,0,1]

21.reverse()方法將數組中元素的位置顛倒，會更改原數組

/**
     * reverse() 方法將數組中元素的位置顛倒
     * arr.reverse()
     *
     * reverse 方法顛倒數組中元素的位置，並返回該數組的引用
     */
    let myArray = ['one', 'two', 'three'];
    myArray.reverse();
    console.log(myArray); // ['three', 'two', 'one']

22.sort()方法對數組的元素進行排序，並返回數組;sort 排序不必定是穩定的,默認排序順序是根據字符串Unicode碼點。會更改原數組

/**
     * sort() 方法對數組的元素進行排序，並返回數組;sort 排序不必定是穩定的,默認排序順序是根據字符串Unicode碼點
     * arr.sort(compareFunction)
     *
     * compareFunction  可選,用來指定按某種順序進行排列的函數
     * 返回值：返回排序後的數組，原數組已經被排序後的數組代替
     */
    let stringArray = ["Blue", "Humpback", "Beluga"];
    let numericStringArray = ["80", "9", "700"];
    let numberArray = [40, 1, 5, 200];
    let mixedNumericArray = ["80", "9", "700", 40, 1, 5, 200];
    function compareNumbers(a, b)
    {
        return a - b;
    }
    console.log(stringArray.sort());//["Beluga", "Blue", "Humpback"]
    console.log(numberArray.sort());//[1,200,40,5]
    console.log(numberArray.sort(compareNumbers));//[1,5,40,200]
    console.log(numericStringArray.sort());//["700", "80", "9"]
    console.log(numericStringArray.sort(compareNumbers));//["9", "80", "700"]
    console.log(mixedNumericArray.sort());//[1, 200, 40, 5, "700", "80", "9"]
    console.log(mixedNumericArray.sort(compareNumbers));//[1, 5, "9", 40, "80", 200, "700"]

23.toString()返回一個字符串，表示指定的數組及其元素

/**
     * toString() 返回一個字符串，表示指定的數組及其元素
     * arr.toString()
     *
     * Array 對象覆蓋了 Object 的 toString 方法
        對於數組對象，toString 方法返回一個字符串，該字符串由數組中的每一個元素的 toString() 返回值經調用 join() 方法鏈接（由逗號隔開）組成
     */
    let monthNames = ['Jan', 'Feb', 'Mar', 'Apr'];
    let myVar = monthNames.toString(); //"Jan,Feb,Mar,Apr"

數組遍歷相關：

1.entries()方法返回一個新的Array Iterator對象，該對象包含數組中每一個索引的鍵/值對

/**
     * entries() 方法返回一個新的Array Iterator對象，該對象包含數組中每一個索引的鍵/值對
     * arr.entries()
     *
     * searchValue  一個字符串表示被查找的值。
     * fromIndex 可選 表示調用該方法的字符串中開始查找的位置。能夠是任意整數。默認值爲 0。
     * 若是 fromIndex < 0 則查找整個字符串（如同傳進了 0）。
     * 若是 fromIndex >= str.length，則該方法返回 -1，除非被查找的字符串是一個空字符串，此時返回 str.length。
     */
    let array = ["a", "b", "c"];
    let iterator = array.entries();
    let a = [];
    for(let i=0; i<= array.length; i++){    // 注意，是length+1，比數組的長度大
        let item = iterator.next();             // 每次迭代時更新next
        console.log(item.done);             // 這裏能夠看到更新後的done都是false
        if(item.done !== true){             // 遍歷迭代器結束done纔是true
            console.log(item.value);
            a[i]=item.value;
        }
    }
    return JSON.stringify(a); //[[0,"a"],[1,"b"],[2,"c"]]

2.keys()返回一個新的Array迭代器，它包含數組中每一個索引的鍵

/**
     * keys() 方法返回一個新的Array迭代器，它包含數組中每一個索引的鍵
     * arr.keys()
     *
     * 返回值：一個新的 Array 迭代器對象
     */
    let array = ["a", "b", "c"];
    let iterator = array.keys();

    console.log(iterator.next()); // { value: 0, done: false }
    console.log(iterator.next()); // { value: 1, done: false }
    console.log(iterator.next()); // { value: 2, done: false }
    console.log(iterator.next()); // { value: undefined, done: true }

3.forEach()方法對數組的每一個元素執行一次提供的函數

/**
     * forEach() 方法對數組的每一個元素執行一次提供的函數
     * array.forEach(callback[, thisArg])
     *
     * callback  在數組每一項上執行的函數，接收 3 個參數：
     element  當前遍歷到的元素。
     index  當前遍歷到的索引。
     array  數組自己
     * thisArg 可選，指定 callback 的 this 參數
     *
     * 返回值：無返回值
     */
    let words = ["one", "two", "three", "four"];
    words.forEach(function(word,index) {
        console.log(word,index); //one,0   two,1   four,2
        if (word === "two") {
            words.shift(); //["two", "three", "four"]
        }
    });
    console.log(words);//["two", "three", "four"]

4.map()返回一個新數組，其結果是該數組中的每一個元素都調用一個提供的函數後返回的結果，不會更改原數組

/**
     * map() 方法建立一個新數組，其結果是該數組中的每一個元素都調用一個提供的函數後返回的結果
     * let new_array = arr.map(function callback(currentValue, index, array) {
            // Return element for new_array
       }[, thisArg])
     *
     * callback  生成新數組元素的函數，使用三個參數：
        currentValue  callback 的第一個參數，數組中正在處理的當前元素。
        index  callback 的第二個參數，數組中正在處理的當前元素的索引。
        array  callback 的第三個參數，map 方法被調用的數組。
     * thisArg  可選的，執行 callback 函數時 使用的this 值
     *
     * 返回值：一個新數組，每一個元素都是回調函數的結果；不修改原數組自己
     */
    let numbers = [1, 4, 9];
    let roots = numbers.map(Math.sqrt); // roots的值爲[1, 2, 3], numbers的值仍爲[1, 4, 9]
    /**
     * 反轉字符串
     */
    let reverseStr =  Array.prototype.map.call("12345", function(x) {
        return x;
    }).reverse().join('');//54321

    let kvArray = [{key: 1, value: 10}, {key: 2, value: 20}, {key: 3, value: 30}];
    let reformattedArray = kvArray.map(function(obj) {
       if (obj.key === 2) {
           obj.value = 40;
       }
       return obj;
    });
    console.log(JSON.stringify(reformattedArray));//[{"key":1,"value":10},{"key":2,"value":40},{"key":3,"value":30}]
    return JSON.stringify(kvArray);//[{"key":1,"value":10},{"key":2,"value":40},{"key":3,"value":30}]