JavaScript中数组对象的那些自带方法
/**
* 本文纯粹是梳理一下目前W3C标准中Array对象的自带Method。
* 全文没啥营养，不过最后性能测试的部分，倒是抛出了一些疑问。
*/
赋值方法 （Mutator methods）
这些方法直接修改数组自身
pop 和 push
Array.pop(); // 删除数组最后一个元素，返回被删除的元素
Array.push(element1, ..., elementN); // 在数组尾部插入1-N个元素，返回操作后数组的length
通过这 pop 和 push ，就能把数组模拟成 堆栈(stack) 来进行操作。
堆栈这种数据结构的特点，就是“后进先出”（LIFO, Last In First Out）。
shift 和 unshift
Array.shift(); // 删除数组第一个元素，返回被删除的元素
Array.unshift(element1, ..., elementN) ; // 在数组头部插入1-N个元素，返回操作后数组的length
利用 shift 和 unshift 则可以实现 队列(queue) 的操作。
队列的操作方式和堆栈相反，采用“先进先出”（FIFO, First-In-First-Out）。
splice
Array.splice(index , howMany[, element1[, ...[, elementN]]]);
Array.splice(index);
参数：
index：规定从何处添加/删除元素。
howmany：规定应该删除多少元素。
elements：规定要添加到数组的新元素，从 index 所指的下标处开始插入。
splice方法是对 pop、push、shift、unshift 的一个补充。
返回值是被删除的元素。
reverse
Array.reverse(); // 颠倒数组中元素的顺序，并返回逆序后的数组
sort
Array.sort([compareFunction]);
如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序。
说得更精确点，是按照字符编码的顺序进行排序。
如果想按照其他标准进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b，其返回值如下：
- 若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
- 若 a 等于 b，则返回 0。
- 若 a 大于 b，则返回一个大于 0 的值。
访问方法（Accessor methods）
这些方法只是返回相应的结果，而不会修改数组本身
concat
Array.concat(value1, value2, ..., valueN); // 链接2个或多个数组，并返回合并后的数组
但有一个需要注意的地方，用下面的例子说明：
1 var arr = [1, 2, 3]; 2 arr.concat(4, 5); // return [1, 2, 3, 4, 5] 3 arr.concat([4, 5]); // return [1, 2, 3, 4, 5] 4 arr.concat([4, 5], [6, 7]); // return [1, 2, 3, 4, 5, 6, 7] 5 arr.concat(4, [5, [6, 7]]); // return [1, 2, 3, 4, 5, [6, 7]]
join
string = Array.join(separator);
把数组中的所有元素放入一个字符串。其中，元素之间是通过指定的分隔符进行分隔的。
默认的分隔符是逗号(,)，返回值是合并后字符串。
1 [1, 2, 3].join(); // return "1,2,3"
Array.join()方法，实际上是String.splite()的逆向操作。
slice
Array.slice(begin[, end]); // 数组中返回选定的元素
toString
Array.toString(); // 这个就不说了，所有JavaScript都有toString这个方法
indexOf 和 lastIndexOf *[ECMAScript 5]
Array.indexOf(searchElement[, fromIndex]); // 从头开始搜索
Array.lastIndexOf(searchElement[, fromIndex]); // 从尾开始搜索
searchElement：需要搜索的值
fromIndex：索引，指示搜索从哪里开始
迭代方法（Iteration methods）
forEach *[ECMAScript 5]
Array.forEach(callback[, thisArg]); // 从头到尾遍历一次数组，并为数组中的每个元素，调用指定的函数
参数：
callback：遍历数组时调用的函数
thisArg：指定 callback 的作用域
另外，callback会调用三个参数：
value：数组元素
index：数组索引
array：数组本身
1 [1, 2].forEach(function(value, index, array) { 2 console.log(value, index, array); 3 }); 4 // return 5 // 1 0 [1, 2] 6 // 2 1 [1, 2]
Note：forEach是无法通过break来中断数组的遍历。
解决方法：利用try方法来抛出异常，终止遍历。
1 try { 2 [1,2,3].forEach(function(val) { 3 console.log(val); 4 throw(e) 5 }); 6 } catch(e) { 7 console.log(e); 8 }
map *[ECMAScript 5]
Array.map(callback[, thisArg]); // 遍历数组元素，调用指定函数，并以数组返回所有结果
参数：
callback：遍历数组时调用的函数
thisObject ：指定 callback 的作用域
例子：
1 [1, 2, 3].map(function(num) { // return [2, 3, 4] 2 return num + 1; 3 });
filter *[ECMAScript 5]
Array.filter(callback[, thisObject]); // 遍历数组调用方法，满足条件(返回true)的元素，将被添加到返回值的数组中
参数：
callback：遍历数组时调用的函数
thisObject ：指定 callback 的作用域
例子：
1 [1, 2, 3].filter(function(num) { // return [1] 2 return num < 2; 3 });
every 和 some *[ECMAScript 5]
Array.every(callback[, thisObject]); // “与”
Array.some(callback[, thisObject]); // “或”
参数：
callback：遍历数组时调用的函数
thisObject：指定 callback 的作用域
every：当所有元素调用函数都返回true，结果才返回true，不然均返回false。
some：当所有元素调用函数都返回false，结果才返回false，不然均返回true。
一旦every和some的返回值确定，就会立刻停止遍历。
例子：
1 [1, 2, 3]. every(function(num) { // return false 2 return num > 1; 3 }); 4 [1, 2, 3]. some(function(num) { // return true 5 return num > 2; 6 });
reduce 和 reduceRight *[ECMAScript 5]
Array.reduce(callback[, initialValue]); // 使用指定的方法将数组元素进行组合，按索引从低到高（从左到右）
Array.reduceRight(callback[, initialValue]); // 使用指定的方法将数组元素进行组合，按索引从高到低（从右到左）
参数：
callback：遍历数组时调用的函数
initialValue：第一个次调用callback时传入的previousValue
另外，callback会调用四个参数：
previousValue：到目前为止的操作累积结果
currentValue：数组元素
index：数组索引
array：数组本身
例子：
1 [1, 2, 3]. reduce(function(x, y) { // return 106 2 return x + y; 3 }, 100);
性能测试
测试系统：Windows 7
测试浏览器：Chrome 26.0.1386.0
1 var arr = []; 2 3 for(var i = 0; i < 999999; i++) { 4 arr.push(i); 5 }
forEach
1 function forEachTest() { 2 howTime("forEach", function() { 3 var num = 0; 4 arr.forEach(function(val, key) { 5 num += val; 6 }); 7 }); 8 9 howTime("for", function() { 10 var num = 0; 11 for(var i = 0, len = arr.length; i < len; i++) { 12 num += arr[i]; 13 } 14 }); 15 }
下面是随机进行的3次测试结果（具体结果与电脑配置有关，结果越小则性能越好）：
| time_forEach | time_for |
| 1421.000ms | 64.000ms |
| 1641.000ms | 63.000ms |
| 1525.000ms | 63.000ms |
可以看到，Chrome并没有对forEach做专门的优化，和直接用for循环遍历相比，性能还是有很大的差距。
因为forEach是 ECMAScript 5 的东西，旧版浏览器并不支持。
不过MDN都有给出向下兼容的解决方法：
1 if(!Array.prototype.forEach) { 2 Array.prototype.forEach = function(fn, scope) { 3 for(var i = 0, len = this.length; i < len; ++i) { 4 fn.call(scope, this[i], i, this); 5 } 6 } 7 }
离谱的是，原生的 forEach 方法，在性能上，居然比不上自己构造的 forEach！
还有，Array对象其他的迭代方法呢？
大家看看这个Demo就基本清楚了：http://maplejan.sinaapp.com/demo/ArratMethod.html
另外，还发现了一个有意思的情况。
如果直接在控制台运行Demo的JavaScript代码，你会发现性能上有很大差异！
这个时候，直接用for循环写的方法，性能会更差。
对于这个疑问，在知乎上提问了，问题地址：http://www.zhihu.com/question/20837774
作者：Maple Jan
