javascript/es5中数组循环函数汇总

1、arr.forEach()： 

arr.forEach(function(value, index, arr){

    console.log(value, index, arr);

})

2、arr.map()：

map()方法会对数组中的每个元素执行一次回调函数，并将回调函数的返回值组成一个新的数组。

map()方法返回一个新的数组，其中包含了回调函数对原始数组元素的处理结果。

正常情况下需配合return，返回一个新的数组，若是没有return，则功能类似forEach() 

let newArr = arr.map(function(value, index, arr){
    return value; //将return后的值添加进新数组
})

• map()方法不会修改原始数组，而是返回一个新数组。
• 回调函数可以返回任何类型的值，并且可以根据需要进行逻辑操作、转换或计算等。

3、arr.filter()：

在 JavaScript 中，filter() 方法是用于过滤数组中的元素的高阶函数。filter() 方法将一个数组中的每个元素传递给一个回调函数，回调函数返回一个布尔值，决定该元素是否应该被过滤出数组。最终，filter() 方法返回一个新的数组，其中包含回调函数返回 true 的元素。

/* 去除重复元素依靠的是indexOf总是返回第一个元素的位置，后续的重复元素位置与indexOf返回的位置不相等，因此被filter滤掉了*/

let r = arr.filter(function (element, index, self) {
        return self.indexOf(element) == index;
});

过滤，过滤一些不合格元素，如果回调函数返回true，就留下来。

• filter() 不会对空数组进行检测；
• filter() 不会改变原始数组。

4、arr.some()：

some() 方法会依次执行数组的每个元素：

如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。

如果没有满足条件的元素，则返回false。

arr.some(function(value, index, arr){


})

5、arr.every()：

every() 方法使用指定函数检测数组中的所有元素：

如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。

如果所有元素都满足条件，则返回 true。

arr.every(function(value, index, arr){


})

注意：对于一个空数组，every() 无论回调函数是什么都会返回 true，因为那个回调函数从未被调用。

function isNumber(value) {
    return typeof value === "number";
}
 
[1].every(isNumber);            // true
["1"].every(isNumber);          // false
[1, 2, 3].every(isNumber);      // true
[1, "2", 3].every(isNumber);    // false
[].every(isNumber);             // true

在这个例子的每种情况下，调用 every() 都是为了检查数组中的每一项是否为数字。前四个调用相当直接，every() 产生了预期的结果。现在考虑这些例子： 

    [].every(() => true);           // true
    [].every(() => false);          // true

这可能更令人惊讶：无论是返回 true 还是 false 的回调，结果都是一样的。唯一的原因是如果回调没有被调用，every() 的默认值是 true。但是，为什么一个空数组会对 every() 返回 true，当没有值去执行回调函数时呢？

要理解原因，重要的是要看看规范是如何描述这个方法的。

实现 every()

ECMA-262 定义了一个 Array.prototype.every() 算法，大致可以翻译成以下的 JavaScript 代码：

Array.prototype.every = function(callbackfn, thisArg) {
 
    const O = this;
    const len = O.length;
 
    if (typeof callbackfn !== "function") {
        throw new TypeError("Callback isn't callable");
    }
 
    let k = 0;
 
    while (k < len) {
        const Pk = String(k);
        const kPresent = O.hasOwnProperty(Pk);
 
        if (kPresent) {
            const kValue = O[Pk];
            const testResult = Boolean(callbackfn.call(thisArg, kValue, k, O));
 
            if (testResult === false) {
                return false;
            }
        }
 
        k = k + 1;
    }
 
    return true;
};

从代码中可以看到，every() 假设结果是 true，并且只有当回调函数对数组中的任何一个条目返回 false 时，才会返回 false。如果数组中没有条目，则没有执行回调函数的机会，因此，该方法无法返回 false。 

6、arr.reduce()：

arr.reduce(function(prev, cur, index, arr){
...
}, init);

arr： 表示原数组；
prev： 最开始时，如果传入了初始值则prev为初始值，如果没有传，则prev为数组第一项；之后，prev表示上一次调用回调时的返回值;
cur： 表示当前正在处理的数组元素；
index： 表示当前正在处理的数组元素的索引，若提供 init 值，则索引为0，否则索引为1；
init： 表示初始值。

求数组项之和

    let arr = [3, 9, 4, 3, 6, 0, 9];
    let sum = arr.reduce(function (prev, cur) {
    return prev + cur;
},0);
    console.log(sum);

由于传入了初始值0，所以开始时prev的值为0，cur的值为数组第一项3，相加之后返回值为3作为下一轮回调的prev值，然后再继续与下一个数组项相加，以此类推，直至完成所有数组项的和并返回。 

求数组项最大值

    let arr = [3, 9, 4, 3, 6, 0, 9];
    let max = arr.reduce(function (prev, cur) {
    return Math.max(prev,cur);
});
    console.log(max);

由于未传入初始值，所以开始时prev的值为数组第一项3，cur的值为数组第二项9，取两值最大值后继续进入下一轮回调。 

数组去重

let arr = [3,9,4,3,6,0,9];
let newArr = arr.reduce(function (prev, cur) {
    prev.indexOf(cur) === -1 && prev.push(cur);
    return prev;
},[]);

7、arr.reduceRight()：