摘要：默認為如果大于等于數(shù)組長度，則返回該數(shù)組不會被搜索返回值一個類型方法返回在數(shù)組中可以找到一個給定元素的第一個索引，如果不存在，則返回。

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

????表示 Array 構(gòu)造函數(shù)的原型，并允許您向所有Array對象添加新的屬性和方法；鮮為人知的事實：Array.prototype 本身也是一個 Array

    /**
     * length屬性：返回或設(shè)置一個數(shù)組中的元素個數(shù)；
     * 該值是一個無符號 32-bit 整數(shù)，并且總是大于數(shù)組最高項的下標(biāo)
     */
    let array = ["shoes", "shirts", "socks", "sweaters"];
    return array.length; // 4

    /**
     * Array.from() 方法從一個類似數(shù)組或可迭代對象中創(chuàng)建一個新的數(shù)組實例
     * Array.from(arrayLike[, mapFn[, thisArg]])
     *
     * arrayLike  想要轉(zhuǎn)換成數(shù)組的偽數(shù)組對象或可迭代對象
     * mapFn (可選參數(shù))  如果指定了該參數(shù)，新數(shù)組中的每個元素會執(zhí)行該回調(diào)函數(shù)
     * thisArg (可選參數(shù))  可選參數(shù)，執(zhí)行回調(diào)函數(shù) 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);  //沒有去重復(fù)的新數(shù)組
        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);

    /**
     * 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

    /**
     * Array.of() 方法創(chuàng)建一個具有可變數(shù)量參數(shù)的新數(shù)組實例，而不考慮參數(shù)的數(shù)量或類型
     * Array.of(element0[, element1[, ...[, elementN]]])
     *
     * elementN  任意個參數(shù)，將按順序成為返回數(shù)組中的元素
     * 返回值：新的 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);

    /**
     * copyWithin() 方法淺復(fù)制數(shù)組的一部分到同一數(shù)組中的另一個位置，并返回它，而不修改其大小
     * arr.copyWithin(target[, start[, end]])
     *
     * target  0 為基底的索引，復(fù)制序列到該位置。如果是負數(shù)，target 將從末尾開始計算。
     * 如果 target 大于等于 arr.length，將會不發(fā)生拷貝。
     * 如果 target 在 start 之后，復(fù)制的序列將被修改以符合 arr.length
     * start  0 為基底的索引，開始復(fù)制元素的起始位置。如果是負數(shù)，start 將從末尾開始計算。
     * 如果 start 被忽略，copyWithin 將會從0開始復(fù)制
     * end   0 為基底的索引，開始復(fù)制元素的結(jié)束位置。copyWithin 將會拷貝到該位置，但不包括 end 這個位置的元素。
     * 如果是負數(shù)， end 將從末尾開始計算。如果 end 被忽略，copyWithin 將會復(fù)制到 arr.length。
     *
     * 返回值：改變了的數(shù)組
     */
    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]

    /**
     * fill() 方法用一個固定值填充一個數(shù)組中從起始索引到終止索引內(nèi)的全部元素
     * arr.fill(value[, start[, end]])    [start,end)
     *
     * value   用來填充數(shù)組元素的值
     * start   可選，起始索引，默認值為0
     * end   可選，終止索引，默認值為 this.length
     *
     * 返回值：修改后的數(shù)組，會改變原數(shù)組
     */
    [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);

    /**
     * concat() 方法用于合并兩個或多個數(shù)組。此方法不會更改現(xiàn)有數(shù)組，而是返回一個新數(shù)組
     * var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
     *
     * valueN  將數(shù)組和/或值連接成新數(shù)組
     */
    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]]

    /**
     * join() 方法將一個數(shù)組（或一個類數(shù)組對象）的所有元素連接成一個字符串并返回這個字符串
     * str = arr.join(separator)
     * separator   指定一個字符串來分隔數(shù)組的每個元素。默認為 ","
     * 如果需要(separator)，將分隔符轉(zhuǎn)換為字符串
     * 如果separator是空字符串("")，則所有元素之間都沒有任何字符
     *
     * 返回值：一個所有數(shù)組元素連接的字符串。如果 arr.length 為0，則返回空字符串
     */
    let array = ["Wind", "Rain", "Fire"];
    let myVar1 = array.join();      // myVar1的值變?yōu)?Wind,Rain,Fire"
    let myVar2 = array.join(", ");  // myVar2的值變?yōu)?Wind, Rain, Fire"
    let myVar3 = array.join(" + "); // myVar3的值變?yōu)?Wind + Rain + Fire"
    let myVar4 = array.join("");    // myVar4的值變?yōu)?WindRainFire"

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

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

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

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

    /**
     * unshift() 方法將一個或多個元素添加到數(shù)組的開頭，并返回新數(shù)組的長度
     * arr.unshift(element1, ..., elementN)
     *
     * element1, ..., elementN   要添加到數(shù)組開頭的元素
     * 返回值：當(dāng)一個對象調(diào)用該方法時，返回其 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]

    /**
     * shift() 方法從數(shù)組中刪除第一個元素，并返回該元素的值;此方法更改數(shù)組的長度
     * arr.shift()
     *
     * 返回值：從數(shù)組中刪除的元素; 如果數(shù)組為空則返回undefined
     */
    let myFish = ["angel", "clown", "mandarin", "surgeon"];
    console.log("調(diào)用 shift 之前: " + myFish);// "調(diào)用 shift 之前: angel,clown,mandarin,surgeon"
    let shifted = myFish.shift();
    console.log("調(diào)用 shift 之后: " + myFish);// "調(diào)用 shift 之后: clown,mandarin,surgeon"
    console.log("被刪除的元素: " + shifted);// "被刪除的元素: angel"

    /**
     * every() 方法測試數(shù)組的所有元素是否都通過了指定函數(shù)的測試
     * arr.every(callback[, thisArg])
     *
     * callback   用來測試每個元素的函數(shù)
     * thisArg   執(zhí)行 callback 時使用的 this 值
     * every 不會改變原數(shù)組
     */
    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;

    /**
     * some() 方法測試數(shù)組中的某些元素是否通過由提供的函數(shù)實現(xiàn)的測試
     * arr.some(callback[, thisArg])
     *
     * callback  用來測試每個元素的函數(shù)，接受三個參數(shù)：
        currentValue 數(shù)組中正在處理的元素
        index 可選,數(shù)組中正在處理的元素的索引值
        array可選,some()被調(diào)用的數(shù)組
     * thisArg  可選,執(zhí)行 callback 時使用的 this 值
     *
     * 返回值：如果回調(diào)函數(shù)返回任何數(shù)組元素的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

    /**
     * filter() 方法創(chuàng)建一個新數(shù)組, 其包含通過所提供函數(shù)實現(xiàn)的測試的所有元素
     * let new_array = arr.filter(callback[, thisArg])
     *
     * callback  用來測試數(shù)組的每個元素的函數(shù)。
     * 調(diào)用時使用參數(shù) (element, index, array),返回true表示保留該元素（通過測試），false則不保留
     * thisArg  可選，執(zhí)行 callback 時的用于 this 的值
     *
     * 返回值：一個新的通過測試的元素的集合的數(shù)組；filter 不會改變原數(shù)組
     */
    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));

    /**
     * find() 方法返回數(shù)組中滿足提供的測試函數(shù)的第一個元素的值。否則返回 undefined
     * arr.find(callback[, thisArg])
     *
     * callback  在數(shù)組每一項上執(zhí)行的函數(shù)，接收 3 個參數(shù)：
     element  當(dāng)前遍歷到的元素。
     index  當(dāng)前遍歷到的索引。
     array  數(shù)組本身
     * thisArg 可選，指定 callback 的 this 參數(shù)
     *
     * 返回值：當(dāng)某個元素通過 callback 的測試時，返回數(shù)組中的一個值，否則返回 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 }
    /**
     * 查找質(zhì)數(shù)
     */
    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

    /**
     * findIndex()方法返回數(shù)組中滿足提供的測試函數(shù)的第一個元素的索引;否則返回-1
     * arr.findIndex(callback[, thisArg])
     *
     * callback  在數(shù)組每一項上執(zhí)行的函數(shù)，接收 3 個參數(shù)：
     element  當(dāng)前遍歷到的元素。
     index  當(dāng)前遍歷到的索引。
     array  數(shù)組本身
     * thisArg 可選，指定 callback 的 this 參數(shù)
     */
    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

    /**
     * includes() 方法用來判斷一個數(shù)組是否包含一個指定的值，根據(jù)情況，如果包含則返回 true，否則返回false
     * arr.includes(searchElement, fromIndex)
     *
     * searchElement  需要查找的元素值
     * fromIndex 可選  從該索引處開始查找 searchElement。
     * 如果為負值，則按升序從 array.length + fromIndex 的索引開始搜索。默認為 0
     * 如果大于等于數(shù)組長度 ，則返回 false,該數(shù)組不會被搜索
     *
     * 返回值：一個 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");

    /**
     * indexOf()方法返回在數(shù)組中可以找到一個給定元素的第一個索引，如果不存在，則返回-1
     * arr.indexOf(searchElement[, fromIndex = 0])
     *
     * searchElement  要查找的元素
     * romIndex  開始查找的位置。其默認值為0
     * 如果該索引值大于或等于數(shù)組長度，意味著不會在數(shù)組里查找，返回-1
     * 如果參數(shù)中提供的索引值是一個負值，則被看作是 arr.length + romIndex ,如果抵消后的索引值仍小于0，則整個數(shù)組都將會被查詢
     * 注意：如果參數(shù)中提供的索引值是一個負值，并不改變其查找順序，查找順序仍然是從前向后查詢數(shù)組
     *
     * 返回值：首個被找到的元素在數(shù)組中的索引位置; 若沒有找到則返回 -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]

    /**
     * lastIndexOf() 方法返回指定元素在數(shù)組中的最后一個的索引，如果不存在則返回 -1。從數(shù)組的后面向前查找，從 fromIndex 處開始
     * arr.lastIndexOf(searchElement[, fromIndex = arr.length - 1])
     *
     * searchElement  被查找的元素
     * fromIndex  從此位置開始逆向查找。默認為數(shù)組的長度減 1，即整個數(shù)組都被查找。
     * 如果該值大于或等于數(shù)組的長度，則整個數(shù)組會被查找。如果為負值，將其視為從數(shù)組末尾向前的偏移。
     * 即使該值為負，數(shù)組仍然會被從后向前查找。如果該值為負時，其絕對值大于數(shù)組長度，則方法返回 -1，即數(shù)組不會被查找
     *
     * 返回值：數(shù)組中最后一個元素的索引，如未找到返回-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];

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

    /**
     * 計算數(shù)組中每個元素的出現(xiàn)次數(shù)
     */
    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}

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

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

    /**
     * sort() 方法對數(shù)組的元素進行排序，并返回數(shù)組;sort 排序不一定是穩(wěn)定的,默認排序順序是根據(jù)字符串Unicode碼點
     * arr.sort(compareFunction)
     *
     * compareFunction  可選,用來指定按某種順序進行排列的函數(shù)
     * 返回值：返回排序后的數(shù)組，原數(shù)組已經(jīng)被排序后的數(shù)組代替
     */
    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"]

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

    /**
     * entries() 方法返回一個新的Array Iterator對象，該對象包含數(shù)組中每個索引的鍵/值對
     * arr.entries()
     *
     * searchValue  一個字符串表示被查找的值。
     * fromIndex 可選 表示調(diào)用該方法的字符串中開始查找的位置。可以是任意整數(shù)。默認值為 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，比數(shù)組的長度大
        let item = iterator.next();             // 每次迭代時更新next
        console.log(item.done);             // 這里可以看到更新后的done都是false
        if(item.done !== true){             // 遍歷迭代器結(jié)束done才是true
            console.log(item.value);
            a[i]=item.value;
        }
    }
    return JSON.stringify(a); //[[0,"a"],[1,"b"],[2,"c"]]

    /**
     * keys() 方法返回一個新的Array迭代器，它包含數(shù)組中每個索引的鍵
     * 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 }

    /**
     * forEach() 方法對數(shù)組的每個元素執(zhí)行一次提供的函數(shù)
     * array.forEach(callback[, thisArg])
     *
     * callback  在數(shù)組每一項上執(zhí)行的函數(shù)，接收 3 個參數(shù)：
     element  當(dāng)前遍歷到的元素。
     index  當(dāng)前遍歷到的索引。
     array  數(shù)組本身
     * thisArg 可選，指定 callback 的 this 參數(shù)
     *
     * 返回值：無返回值
     */
    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"]

    /**
     * map() 方法創(chuàng)建一個新數(shù)組，其結(jié)果是該數(shù)組中的每個元素都調(diào)用一個提供的函數(shù)后返回的結(jié)果
     * let new_array = arr.map(function callback(currentValue, index, array) {
            // Return element for new_array
       }[, thisArg])
     *
     * callback  生成新數(shù)組元素的函數(shù)，使用三個參數(shù)：
        currentValue  callback 的第一個參數(shù)，數(shù)組中正在處理的當(dāng)前元素。
        index  callback 的第二個參數(shù)，數(shù)組中正在處理的當(dāng)前元素的索引。
        array  callback 的第三個參數(shù)，map 方法被調(diào)用的數(shù)組。
     * thisArg  可選的，執(zhí)行 callback 函數(shù)時 使用的this 值
     *
     * 返回值：一個新數(shù)組，每個元素都是回調(diào)函數(shù)的結(jié)果；不修改原數(shù)組本身
     */
    let numbers = [1, 4, 9];
    let roots = numbers.map(Math.sqrt); // roots的值為[1, 2, 3], numbers的值仍為[1, 4, 9]
    /**
     * 反轉(zhuǎn)字符串
     */
    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}]