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

    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);

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

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

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

    /**
     * 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() 方法創建一個具有可變數量參數的新數組實例，而不考慮參數的數量或類型
     * 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);

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

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

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

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

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

    /**
     * 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); //[]

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

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

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

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

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

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

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

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

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

    /**
     * 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");

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

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

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

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

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

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

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

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

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

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

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