JavaScript数组方法ES5

数组中可调用方法

栈方法：

push()

增加数组最后的元素

   var colors = ["pink"];
   add = colors.push("red", "blue");
   alert(add);	//3
   alert(colors);	//pink,red,blue

pop()

删除数组最后的元素

	var colors = ["pink", "red", "blue"];
	sub = colors.pop()
	alert(sub);	//blue
	alert(colors);	//pink,red

队列方法：

shift()对push()

push增加数组最后元素，shift删除数组最前元素

	var colors = ["pink", "red", "blue"];
	sub = colors.shift();
	alert(sub);	//pink
	alert(colors);	//red,blue

unshift()对pop()

unshift增加数组最前元素，pop删除数组最后元素

	var colors = ["pink", "red", "blue"];
	add = colors.unshift("perple");
	alert(add);   //4
	alert(colors);  //perple,pink,red,blue

重排序方法：

reverse()

对数组进行降序排序。（不够灵活）

	var values = [0, 5, 15, 10, 1];
	a =values.reverse();
	alert(a);	//1,10,15,5,0

sort()

对数组转化成字符串再对字符串进行升序排序。
PS：若想sort方法进行数字的升序排序，需要给sort()加入自定义的compare方法：

	function compare(value1, value2) {
		return value1 - value2;
	}

再调用sort(compare)就可以对数字进行升序排序；
sort的字符串升序排序

	var values = [0, 5, 15, 10, 1];
	a =values.sort();
	alert(a);	//0,1,10,15,5

sort的数字升序排序

	function compare(value1, value2) {
		return value1 - value2;
	}
	var values = [0, 5, 15, 10, 1];
	a =values.sort(compare);
	alert(a);	//0,1,5,10,15

操作方法：

concat()

创建一个数组元素并且合并到当前数组的最后位置

	var values = [0, 5, 15, 10, 1];
	a =values.concat(16, 18);
	alert(a); //0,5,15,10,1,16,18

slice()

创建一个数组并复制数组到新创建的数组:

slice(1,4):复制第1个下标的数组元素到第三个数组下标的元素
（不包含第四个数组下标）
slice(1)：复制除了第0个下标的元素

	var values = [0, 5, 15, 10, 1];
	a =values.slice(1, 4);
	alert(a); //5,15,10

	var values = [0, 5, 15, 10, 1];
	a =values.slice(1);
	alert(a); //5,15,10,1

splice()

对数组进行删除、插入、替换等操作：

splice(第i个位置下标开始， 处理几个元素， 插入、替换的元素)
splice(2, 0, "red", "blue");//在第2个下标
开始插入red和blue元素
splice(0,2);//在第0个下标开始，删除俩个元素

删除

	var values = [0, 5, 15, 10, 1];
	a =values.splice(1,2);
	alert(a); //5,15
	alert(values); //0,10,1

插入

	var values = [0, 5, 15, 10, 1];
	a =values.splice(1,0,6,8);
	alert(a); //空
	alert(values); //0,6,8,5,15,10,1

替换

	var values = [0, 5, 15, 10, 1];
	a =values.splice(1,1,6,8);
	alert(a); //5
	alert(values); //0,6,8,15,10,1

位置方法

indexOf()

从数组开头（位置0）向后查找

lastIndexOf()

从数组末尾开始向前查找

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

迭代方法

every()

传入每个项都满足表达式，就返回true，否则返回false

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

some()

传入有一项满足表达式，就返回true，否则返回false

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

filter()

对满足表达式的筛选并返回一个新的数组

 var numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1];
  var everyResult = numbers.filter(function (item, index, array) {
    return item > 2;
  });
  alert(everyResult); //3,4,5,4,3

map()

对全部项都进行同一算法运算，再返回一个新的数组

  var numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1];
  var everyResult = numbers.map(function (item, index, array) {
    return item * 2;
  });
  alert(everyResult); //2,4,6,8,10,8,6,4,2

forEach()

对数组的每个项都执行同样的操作，如遍历每一项，即遍历数组：

  var numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1];
  var everyResult = numbers.forEach(function (item, index, array) {
    console.log(item);
  });//后台输出如下
  /*
  1
  2
  3
  4
  5
  4
  3
  2
  1
   */

归并方法

俩个都是汇总，只不过是汇总运算时候从数组进入的方向相反。

reduce()

prev是前一个值，默认为0，cur是当前数组当前项的值。prev，cur，index，array

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

reduceRight()

与reduce相同，不过汇总时候，遍历数组是从末尾5开始向前，与reduce遍历数组反向

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

方法调用后各方法可返回的值：

values = push("566");

push和unshift返回运算之后的数组个数；
pop和shift返回运算之后被删除的元素；
reverse、sort和concat返回运算之后的数组；
slice返回运算之后复制出来的数组；
splice返回运算之后被删除的元素；
every和some运算之后返回boolean值；
filter、map和forEach运算之后返回新的数组；
forEach返回该方法对数组项利用后的输出；
reduce和reduceRight返回汇总的值；