JavaScript数组常用方法

在javaScript中，数组恐怕是除了Object之外最常用的类型了，它不仅每一项可以保存任何类型的值，而且其长度可以动态调整。

1、toLocaleString()、toString()、valueOf()和join([separator])

    这三个方法中，前两个方法把数组转换成字符串，valueOf()会返回数组本身。在调用前两个方法时，会分别调用每一项的相对应的方法。
    join()可以使用不同的分隔符将数组转换成字符串。
    join([separator])
    @param separator 可选，分隔符，可以是逗号、分号、减号等。若不传参，则默认是逗号分隔。

var p1 = {
    toLocaleString: function(){
        return "Nikolaos";
    },
    toString: function(){
        return "Nicholas";
    }
};
var p2 = {
    toLocaleString: function(){
        return "Grigorios";
    },
    toString: function(){
        return "Greg";
    }
};
var arr = [p1, p2];
console.log(arr.toLocaleString()); // "Nikolaos,Grigorios"
console.log(arr.toString());       // "Nikolaos,Greg"
console.log(arr.valueOf());          // arr本身

// 更明显的valueOf()
var res = [1, 2, 3];
console.log(res.valueOf()); // [1, 2, 3]

2、push()和pop()

push(item1, item2, ...);
push()方法接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后的数组长度。
pop()方法则从数组末尾移除移除最后一项，减少数组的length值，并返回移除的项。

var color = new Array();;
console.log(color.push("red", "blue")); // 2
console.log(color); // ["red", "blue"]
console.log(color.pop()); // blue
console.log(color);  // ["red"]

3、shift()和unshift()
shift()方法是从数组头部移除第一项并返回该项，同时将数组长度减1。
unshift(item1, item2, ...)

unshift()方法能在数组前端添加任意个项并返回新数组的长度。

var color = ["red"];
console.log(color.unshift("yellow", "green"));  // 3
console.log(color);  // ["yellow", "green", "red"]
console.log(color.shift()); // yellow
console.log(color); // ["green", "red"]

4、sort()和reverse()

sort(fn)对数组进行排序，默认是升序，不管数组中的每一项是什么类型，在排序时都会调用每个数组项的toString()方法，然后比较得到的字符串，显然是不太准确的。因此可给它传递一个比较函数，一个简单的比较函数（升序）如下：

function compare(value1, value2){
	if(value1 < value2){
		return -1;
	}else if(value1 > value2){
		return 1;
	}else{
		return 0;
	}
}

对于数值类型或其valueOf()方法会返回数值类型的对象类型，可以使用更简单的比较函数。

function compare(a,b){
    return a - b;
}

若是想降序，则把返回值对调即可。

reverse()反转数组的顺序。

var arr = [0,1,15,10,5];
console.log(arr.sort());  // [0,1,10,15,5]
console.log(arr.sort(compare));  // [0,1,5,10,15]
console.log(arr.reverse());  // [15,10,5,1,0]

5、concat()、slice()和splice()

（1）concat(item1, item2, ...)

concat()方法可以基于当前数组中的所有项创建一个新数组，换句话说，它会先创建当前数组的副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。

var value = [1,2];
var value2 = value.concat(3,[4,5],{key: 6});
console.log(value);  // [1,2]
console.log(value2);  // [1,2,3,4,5,{key: 6}]

由上面的结果可以看出，如果传递的是一或多个数组，则该方法会将数组的每一项都添加到结果数组中，若不是数组，那么这些值会被简单地添加到结果数组的末尾。

（2）slice([start, end])
@param start 可选，返回项的起始位置
@param end 可选，返回项的结束位置

var value = [1,2,3,4,5];
var value2 = value.slice();
var value3 = value.slice(2);
var value4 = value.slice(2, 4);
var value5 = value.slice(-2, -1);
var value6 = value.slice(-2, -5);
var value7 = value.slice(5);
var value8 = value.slice(6);
var value9 = value.slice(-6);
console.log(value2);  // [1,2,3,4,5]
console.log(value3);  // [3,4,5]
console.log(value4);  // [3,4]
console.log(value5);  // [4]
console.log(value6);  // []
console.log(value7);  // []
console.log(value8);  // []
console.log(value9);  // [1,2,3,4,5]
console.log(value);   // [1,2,3,4,5]

由上面例子分析得到以下结论：
①不传参时，返回数组本身（value2）；
②传一个参数时，返回从该参数指定位置开始到当前数组末尾的所有项（value3）。但是如果该参数大于数组的索引，返回空数组（value7,value8），若该参数与长度的和是负数的话，返回数组本身（value9）；
③传两个参数时，返回起始和结束位置之间的项——但不包括结束位置的项（value4）。若参数中有负数，则用数组长度加上该数来确定相应的位置（value5）。如果结束位置小于开始位置，返回空数组（value6）。

④此方法不会影响原始数组（value）。

（3）splice()

splice()恐怕要算是最强大的数组方法了，下面我们就来领教一下。

①splice(start,end)，删除功能，可以删除任意数量的项。
    @param start 要删除的第一项的位置
    @param end 要删除的项数
    @return 返回删除的项数

看下面例子：（以下代码执行顺序无关联，假设value不变）

var value = [1,2,3,4,5];
var value2 = value.splice();
console.log(value2); // []
var value3 = value.splice(2);
console.log(value3); // [3,4,5]
var value4 = value.splice(2, 2);
console.log(value4); // [3,4]
var value5 = value.splice(5);
console.log(value5); // []
var value6 = value.splice(2, 0);
console.log(value6); // []

由上面例子可得出如下结论：
不传参时，不删除任何项，返回空数组；
传一个参数时，删除从该参数指定位置开始到当前数组末尾的所有项。若是该参数大于数组索引，返回空数组，原数组不变。

传两个参数时，若第二个参数为0或者是负数，则返回空数组（不删除任何项），原数组不变。

②splice(start, 0, item1,item2,...) 插入功能，可以向指定位置插入任意数量的项。

  @param start 起始位置
  @param 0 要删除的项数
  @param item1,item2, ... 要插入的项
  @return [] 返回空数组

var value = [1,2,3,4,5];
var value2 = value.splice(2,0,6,7,8);
console.log(value); // [1,2,6,7,8,3,4,5]
console.log(value2); // []

③splice(start,count,item1,item2,...) 替换功能，可以向指定位置插入任意数量的项，且同时删除任意数量的项。

  @param start 起始位置
  @param count 要删除的项数
  @param item1,item2,...要插入的任意数量的项
  @return 返回删除的项

var value = [1,2,3,4,5];
var value2 = value.splice(2,1,6,7,8);
console.log(value); // [1,2,6,7,8,4,5]
console.log(value2); // [3]

6、indexOf()和lastIndexOf()

这两个参数都接收两个参数：要查找的项和（可选的）表示查找起点位置的索引，并返回要查找的项在数组中的位置，若没有找到，就返回-1。在比较第一个参数与数组的每一项时，会使用全等操作符，也就是说，要求查找的项必须严格相等（就像使用===一样）。indexOf()从数组的开头（位置0）开始向后查找，lastIndexOf()则从数组的末尾开始向前查找。

var numbers = [1,2,3,4,5,4,3,2,1];
console.log(numbers.indexOf(4));   // 3
console.log(numbers.lastIndexOf(4));  // 5
console.log(numbers.indexOf(4, 4));  // 5
console.log(numbers.lastIndexOf(4, 4)); // 3 

var person = {name: "Nicholas"};
var people = [{name: "Nicholas"}];
var morePeople = [person];
console.log(people.indexOf(person));  // -1(不全等，地址不同)
console.log(morePeople.indexOf(person)); // 0

7、every()和some()

every()对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true。
some()对数组中的每一项运行给定函数，如果该函数对任意一项返回true，则返回true。
every()和some()就像双胞胎一样。

var numbers = [1,2,3,4,5,4,3,2,1];
var everyResult = numbers.every(function(item,index,array){
	return (item > 2);
});
console.log(everyResult);  // false
var someResult = numbers.some(function(item, index, array){
	return (item > 2);
});
console.log(someResult);  // true

8、filter和map()

filter()对数组中的每一项运行给定函数，返回该函数会返回true的项组成的数组。
map()对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。

var numbers = [1,2,3,4,5,4,3,2,1];
var filterResult = numbers.filter(function(item,index,array){
	return (item > 2);
});
console.log(filterResult); // [3,4,5,4,3]
var mapResult = numbers.map(function(item, index, array){
	return item * 2;
});
console.log(mapResult);  // [2,4,6,8,10,8,6,4,2]

9、forEach()

forEach对数组中的每一项运行给定函数。此方法无返回值，本质上与使用for循环迭代数组一样。

var numbers = [1,2,3,4,5,4,3,2,1];
numbers.forEach(function(item,index,array){
    // 执行某些操作
    console.log(item, index,array);
});

10、reduce()

reduce(fn, [number])
@param fn 在每一项上调用的函数
@param [number] 可选，作为归并基础的初始值

迭代数组的所有项，然后构建一个最终返回的值。传给它的函数接收4个参数：前一个值、后一个值、项的索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。

var numbers = [1,2,3,4,5];
var sum = numbers.reduce(function(prev, cur, index, array){
	return prev + cur;
});
console.log(sum);  // 15

以上就是js数组比较常用的方法了，如有错误，请大家指正！

ps：以下是简单的总结

（1）forEach()和map()的相同点和不同点分别是什么？
答：它们都是循环遍历数组的每一项，所传递的匿名函数都有三个参数：数组项item、当前项的索引index、原始数组array。但是forEach()没有返回值，而map()有返回值。