JavaScript引用类型---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);

    表示 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}]