- A+
JS中，数组可以通过 Array 构造函数或 [] 字面量的方式创建。数组是一个特殊的对象，继承自 Object 原型，但用 typeof 判断时，并没有一个特定的值，仍然返回 'object'。但使用 [] instanceof Array 返回 true。这说明，JS中存在一个类数组的对象，就像字符串对象或 arguments 对象。arguments 对象不是数组的实例，但仍然有 length 属性，值也可以被索引，因此也可以像数组一样被循环遍历。
这篇文章中，我将盘点下定义在 Array 原型上的一些常用的方法，并逐一介绍其用法。
- 循环 .forEach
- 断言 .some，.every
- 连接与合并 .join，.concat
- 栈与队列 .pop, .push, .shift, .unshift
- 模型映射 .map
- 过滤 .filter
- 排序 .sort
- 聚合 .reduce, .reduceRight
- 截取 .slice
- 删除插入 .splice
- 查找值 .indexOf
- 查找键 in 操作符
- 颠倒 .reverse
1.forEach()
forEach 对数组的所有成员依次执行且只执行一次参数函数，参数函数包含以下3个参数:
- value 当前值
- index 当前位置，索引值
- array 当前数组
进一步，可以传递一个可选参数用于指定函数里的 this 上下文。
['_', 't', 'a', 'n', 'i', 'f', ']'].forEach(function (value, index, array) { this.push(String.fromCharCode(value.charCodeAt() + index + 2)) }, out = []) out.join('') // <- 'awesome' forEach的缺陷是既不能中断循环，也不能抛出异常。
2.some(), every()
这两个方法类似“断言”（assert），返回一个布尔值，表示判断数组成员是否符合某种条件。
类似于 forEach，同样接受一个包含 value, index, and array的回调函数作为参数，而且也可以指定 上下文中的this。
some方法是只要一个成员的返回值是true，则整个some方法的返回值就是true，否则返回false。
every方法是所有成员的返回值都是true，整个every方法才返回true，否则返回false。
max = -Infinity satisfied = [10, 12, 10, 8, 5, 23].some(function (value, index, array) { if (value > max) max = value return value < 10 }) console.log(max) // <- 12 satisfied // <- true 3.join() and concat()
这两个方法容易搞混，join是将数组内各个成员用分隔符连接成一个字符串，分隔符默认是 ,,concat用于多个数组的合并。它将新数组的成员，添加到原数组成员的后部，然后返回一个新数组，原数组不变。
var a = { foo: 'bar' } var b = [1, 2, 3, a] var c = b.concat() console.log(b === c) // <- false b[3] === a && c[3] === a // <- true 4.pop, .push, .shift, and .unshift
每个人都知道往数组末尾添加一个元素是用push方法，但你知道可以一次性添加多个元素吗，像这样 [].push('a', 'b', 'c', 'd', 'z').
pop是push方法的逆操作，去除数组最后一个元素同时返回这个元素，如果是空数组则返回 undefined，使用这两个方法很容易实现 LIFO(last in first out) 栈结构。
function Stack () { this._stack = [] } Stack.prototype.next = function () { return this._stack.pop() } Stack.prototype.add = function () { return this._stack.push.apply(this._stack, arguments) } stack = new Stack() stack.add(1,2,3) stack.next() // <- 3 相应的，我们可以通过 .unshift and .shift 实现一个 FIFO (first in first out)队列。
function Queue () { this._queue = [] } Queue.prototype.next = function () { return this._queue.shift() } Queue.prototype.add = function () { return this._queue.unshift.apply(this._queue, arguments) } queue = new Queue() queue.add(1,2,3) queue.next() // <- 1 使用 .shift (or .pop) 很容易用while循环清空一个数组，如下：
list = [1,2,3,4,5,6,7,8,9,10] while (item = list.shift()) { console.log(item) } list // <- [] 5.map()
map方法将数组的所有成员依次传入回调函数，然后把每一次的执行结果组成一个新数组返回。
方法签名类似于 forEach，.map(fn(value, index, array), thisArgument).
values = [void 0, null, false, ''] values[7] = void 0 result = values.map(function(value, index, array){ console.log(value) return value }) // <- [undefined, null, false, '', undefined × 3, undefined] undefined × 3 表明了回调函数不会在已删除或未赋值的成员执行，而是自己返回包含在返回数组中。Map在映射或转换数组时非常有用，比如下面这个例子：
// casting [1, '2', '30', '9'].map(function (value) { return parseInt(value, 10) }) // 1, 2, 30, 9 [97, 119, 101, 115, 111, 109, 101].map(String.fromCharCode).join('') // <- 'awesome' // a commonly used pattern is mapping to new objects items.map(function (item) { return { id: item.id, name: computeName(item) } }) 6.filter()
filter方法用于过滤数组成员，满足条件的成员组成一个新数组返回。
使用类似于，.filter(fn(value, index, array), thisArgument).
[void 0, null, false, '', 1].filter(function (value) { return value }) // <- [1] [void 0, null, false, '', 1].filter(function (value) { return !value }) // <- [void 0, null, false, ''] 7.sort(compareFunction)
sort方法对数组成员进行排序，默认是按照字典顺序排序。排序后，原数组将被改变。
像大多数的排序函数一样，Array.prototype.sort(fn(a,b)) 接受一个回调函数用于比较 a,b 的大小，而且为下面三种情况之一：
- return value < 0 if a comes before b
- return value === 0 if both a and b are considered equivalent
- return value > 0 if a comes after b
[9,80,3,10,5,6].sort() // <- [10, 3, 5, 6, 80, 9] [9,80,3,10,5,6].sort(function (a, b) { return a - b }) // <- [3, 5, 6, 9, 10, 80] 8.reduce(), reduceRight()
Reduce函数一开始很难理解，这些函数会循环数组，从左向右 (.reduce) 或从右向左 (.reduceRight)，每次回调函数执行时会接受之前的部分结果，最终返回值是单个聚合的值。
两个方法具有相同的语法：
reduce(callback(previousValue, currentValue, index, array), initialValue) previousValue 是上次回调函数执行的返回值，或者第一次执行时的初始值；currentValue 是当前值；index 是当前值位置；array 是执行reduce方法数组的引用；initialValue 是初始值；
.reduce方法的一个典型应用场景是数组成员求和：
Array.prototype.sum = function () { return this.reduce(function (partial, value) { return partial + value }, 0) }; [3,4,5,6,10].sum() // <- 28 9.slice()
slice()方法用于提取目标数组的一部分，返回一个新数组，原数组不变。
arr.slice(start, end) 它的第一个参数为起始位置（从0开始，会包括在返回的新数组之中），第二个参数为终止位置（但该位置的元素本身不包括在内）。如果省略第二个参数，则一直返回到原数组的最后一个成员。
与concat()类似，slice()如果没有任何参数则返回原数组的浅拷贝。Array.prototype.slice可以用来将类数组的对象转换成真正的数组。
Array.prototype.slice.call({ 0: 'a', 1: 'b', length: 2 }) // <- ['a', 'b'] concat做不到，它会返回一个包含传入对象的数组。
Array.prototype.concat.call({ 0: 'a', 1: 'b', length: 2 }) // <- [{ 0: 'a', 1: 'b', length: 2 }] 10.splice()
.splice 是我最喜欢的array原生数组方法，它允许你在一次性在同一个位置删除、插入元素，注意：这个函数会改变原数组。
var source = [1,2,3,8,8,8,8,8,9,10,11,12,13] var spliced = source.splice(3, 4, 4, 5, 6, 7) console.log(source) // <- [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ,13] spliced // <- [8, 8, 8, 8] 你可能注意到了，它会返回被删除的元素，这个常用于循环被删除的元素，你之前可能忘记了。
var source = [1,2,3,8,8,8,8,8,9,10,11,12,13] var spliced = source.splice(9) spliced.forEach(function (value) { console.log('removed', value) }) // <- removed 10 // <- removed 11 // <- removed 12 // <- removed 13 console.log(source) // <- [1, 2, 3, 8, 8, 8, 8, 8, 9] 11.indexOf()、lastIndexOf()
indexOf方法返回给定元素在数组中第一次出现的位置，如果没有出现则返回-1。
var a = { foo: 'bar' } var b = [a, 2] console.log(b.indexOf(1)) // <- -1 console.log(b.indexOf({ foo: 'bar' })) // <- -1 console.log(b.indexOf(a)) // <- 0 console.log(b.indexOf(a, 1)) // <- -1 b.indexOf(2, 1) // <- 1 lastIndexOf方法返回给定元素在数组中最后一次出现的位置，如果没有出现则返回-1。
注意，这两个方法不能用来搜索NaN的位置，即它们无法确定数组成员是否包含NaN。
这是因为这两个方法内部，使用严格相等运算符（===）进行比较，而NaN是唯一一个不等于自身的值。
12.in 操作符
in 用于查找 key 在一个数组中是否存在，indexOf则是查找值。当然速度快于 indexOf.
var a = [1, 2, 5] 1 in a // <- true, but because of the 2! 5 in a // <- false var a = [3, 7, 6] 1 in a === !!a[1] // <- true in 操作符跟把相应位置的值转化为布尔值类似。!! 表达式常用于将一个值取反然后再取反，这是一种高效的将真值转为布尔值的方式。
13.reverse()
reverse方法用于颠倒排列数组元素，返回改变后的数组。注意，该方法将改变原数组。
var a = ['a', 'b', 'c']; a.reverse() // ["c", "b", "a"] a // ["c", "b", "a"] 
