ECMAScript 5 新增的数组方法

ECMAScript中有9种新增数组方法，完成遍历、映射、过滤、检测、简化和搜索功能。

一、forEach

forEach()方法不可停止(break)地进行数组遍历，forEach第一个参数必须为一个匿名函数，该匿名函数有三个参数：数组元素、索引、数组本身。

var arrForEach = [1, 2, 3, 4, 5];
var sum = 0;

/*使每个元素累加,return 15*/
arrForEach.forEach(function(value) {
    sum += value;
})

/*使每个元素加1，arrForEach:[2,3,4,5,6]*/
arrForEach.forEach(function(value,i,a) {
    a[i] = value + 1;
})

/*如果arrForEach是稀疏数组,arrForEach:[2, 3, undefined × 1, 5, 6, undefined × 2, 9]*/
arrForEach = [1, 2, , 4, 5, , , 8];
arrForEach.forEach(function(value,i,a) {
    a[i] = value + 1;
})

/*类数组对象如果想调用forEach方法，可以使用Array原型调用的方式*/
arrLike = {
    0: 1,
    1: 2,
    2: 3,
    length: 3
}

/*arrLike:{0: 2, 1: 3, 2: 4, length: 3}*/
Array.prototype.forEach.call(arrLike, function(value,i,a) {
    a[i] = ++value;
})

二、map

map功能和forEach有相同之处，map也对数组进行遍历，也可以传入代表元素、元素索引、数组的参数，也需要传入一个函数指定元素的运算方式，传入函数的参数为数组元素。

/*arrMap不会修改原数组，但是是需要传入的函数有返回值,arrMap:[1,2,3,4],arrMap2:[2,3,4,5]*/
var arrMap = [1, 2, 3, 4];
var arrMap2 = arrMap.map(function(x) {
    return ++x;
})

/*将数组每一个向前移动，最前的和最后的互换,arrMap:[1,2,3,4],arrMap2:[2,3,4,1]*/
var arrMap = [1, 2, 3, 4];
var temp = arrMap[0];
var arrMap2 = arrMap.map(

function(value, i, a) {
    if (i == a.length - 1)

    return a[i] = temp;

    else return a[i] = a[i + 1];

})

/*类数组对象元素位置各向前移一位，头尾互换*/
var arrLike = {
    0: "零",
1: "壹",
2: "贰",
3: "叁",
4: "肆",
length: 5
};
var temp = arrLike.0;
var arrLike2 = Array.prototype.map.call(arrLike, function(value,i,a) {
    if (i == a.length - 1) return a[i] = temp;
    else return a[i] = a[i + 1];
})

 三、filter
filter方法接受一个参数函数，该参数函数会遍历调用数组的元素，然后进行逻辑判断，返回调用数组中符合参数函数设置条件的元素组成的数组。filter不会修改调用数组。

var arrFilter = [1, 2, 3, 4, 5];

/*返回大于3的元素组成的数组*/
arrFilter.filter(function(x) {
    return x > 3;
})

/*返回索引是偶数的数组,return:['a','c']*/
arrFilter = ['a', 'b', 'c', 'd'];
arrFilter.filter(function() {
    return i % 2 == 0;
})

/*类数组对象调用filter，返回对象成员中含有数字的,retArr:["a1", "b2", "c3", "e5"]*/
var arrLike = {
    0: 'a1',
    1: 'b2',
    2: 'c3',
    3: 'd',
    4: 'e5',
    length: 5
};
var retArr = Array.prototype.filter.call(arrLike, function(x) {
    return /\d/.test(x);
})

/*字符串调用filter判断是否全为数字,return ["1", "2", "3", "4", "5", "6"]*/
var strEvery = '123456e';
var retArr=Array.prototype.filter.call(strEvery, function(x) {
    return /\d/.test(x)
})

 四、every

every函数能判断出数组内的元素是否同时满足任何一个条件，参数为判断逻辑函数，返回值为true 或false。

/*判断数组元素是否全为奇数，return: true*/
var arrEvery = [1, 3, 5, 7, 9];
arrEvery.every(function(x) {
    return x % 2 == 1
})

/*类数组对象调用every，判断成员是否全部为数字,return false*/
var arrLike = {
    0: 1,
    1: 2,
    2: 3,
    3: 'three',
    length: 4
};
Array.prototype.every.call(arrLike, function(x) {
    return /\d/.test(x)
})

/*字符串调用every判断是否全为数字,return false*/
var strEvery = '123456e';
Array.prototype.every.call(strEvery, function(x) {
    return /\d/.test(x)
})

五、some

some和every有相似的用法，every要求每一元素都能满足条件函数的逻辑，而some只要求有一个就足够，并且，some的参数函数一旦判断逻辑满足后就会停止遍历。

var arrSome = ['d', 'e', 3, 4, 5],
    count = 0; //count为计数器，标识some的参数函数遍历到第几个元素。
arrSome.some(function(x) {
    console.log(x + ',' + (count++).toString());
    return /\d/.test(x);
})
/*console.log出来的数据为：
d,0
 e,1
 3,2
可见，some遍历到满足条件的数据后就停止了
*/

六、reduce

reduce的作用是求各元素以一定逻辑组合起来的总值。它的参数是一个函数和需要进行运算的初始值，当这个初始值没有传送的时候，将使用第一个元素作为初始值。

reduce的参数函数的遍历运算法则是，逐值累加。

reduce累加并不只是数值上的累加，如若调用的数组元素是对象，那这个累加就是把各个对象合并成一个新对象。

/*求数组各元素积的和，return 720*/
var arrReduce = [1, 2, 3, 4, 5, 6],
 arrBack1 = arrReduce.reduce(function(x, y) {
 return x * y; //x,y分别代表第一二个元素，它们的积作为第二次运算的x,而此时的y为第三个元素......
});

/*初始值是2，求数组各元素积的和，return 1440*/
 arrBack2 = arrReduce.reduce(function(x, y) {
    return x * y; //x,y分别代表reduce第二个参数，数组第一个元素，它们的积作为第二次运算的x,而此时的y为第二个元素......
}, 2);

/*求数组的最大值,return 6*/
 arrBack2 = arrReduce.reduce(function(x, y) {
    return x > y ? x : y;
})

/*元素为对象的数组调用reduce,return : {x:1,y:2,z:3}*/
var arrObject = [
 {x: 1}, 
 {y: 2},
 {z: 3}
 ];
 arrBack3 = arrObject.reduce(function(o, p) {
 for (prop in p) {
 o[prop] = p[prop]
 }
 return o;
})

七、reduceRight

reduceRight是reduce的逆向版，reduce是从索引低向高进行折叠，而reduceRight则是从高到低。

/*以字符串调用该方法示例，逆排字符串，strRet:逆排后是：654321*/
var str = '123456';
 strRet=[].reduceRight.call(str, function(x, y) {
    return x + y;
}, '逆排后是：')

八、indexOf

indexOf的功能是找出所需查找的元素第一次出现的位置索引，没有找到就为返回-1，类似字符串的indexOf函数。

indexOf接受两个参数，第一个参数指定的是需要找的元素，第二个则是相对于数组开始位置的偏移量，也即是从第二个参数指定的位置开始向右搜索第一个参数。

var arrIndexOf=[1,2,3,3,3,4,5],
    indexRet;
indexRet=arrIndexOf.indexOf(3);//indexRet==2
indexRet=arrIndexOf.indexOf(6);//indexRet==-1
indexRet=arrIndexOf.indexOf(3,3);//indexRet==-1

九、lastIndexOf

indexOf是从左往右索引，而lastIndexOf则是从右开始找元素第一次出现的位置所在索引。

同样，lastIndexOf的第二参数则是指定从数组末位开始的偏移量

var arrLastIndexOf=[1,2,3,3,3,4,5],
    indexRet;
indexRet=arrLastIndexOf.lastIndexOf(3);//indexRet==4
indexRet=arrLastIndexOf.lastIndexOf(3,3);//indexRet==3