在JavaScript中，建立数组能够运用Array组织函数，或许运用数组直接量[],后者是首选要领。Array对象继续自Object.prototype,对数组实行typeof操纵符返回object而不是array。然则，[] instanceof Array也返回true。也就是说，类数组对象的完成更庞杂，比方strings对象、arguments对象，arguments对象不是Array的实例，但有length属性，并能经由过程索引取值，所以能像数组一样举行轮回操纵。
在本文中，我将温习一些数组原型的要领，并探究这些要领的用法。
轮回：.forEach
推断：.some和.every
辨别.join和.concat
栈和行列的完成：.pop, .push, .shift,和 .unshift
模子映照：.map
查询：.filter
排序：.sort
盘算：.reduce和.reduceRight
复制：.slice
壮大的.splice
查找：.indexOf
操纵符：in
走近.reverse
轮回：.forEach
这是JavaScript中最简朴的要领，然则IE7和IE8不支持此要领。
.forEach 有一个回调函数作为参数，遍历数组时，每一个数组元素均会挪用它，回调函数接收三个参数：
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'后文会说起.join，在这个示例中，它用于拼接数组中的差别元素，效果相似于out[0] + ” + out[1] + ” + out[2] + ” + out[n]。
不能中缀.forEach轮回，而且抛出异常也是不明智的挑选。荣幸的事我们有别的的体式格局来中缀操纵。
推断：.some和.every
假如你用过.NET中的罗列，这两个要领和.Any(x => x.IsAwesome) 、 .All(x => x.IsAwesome)相似。
和.forEach的参数相似，须要一个包括value，index，和array三个参数的回调函数，而且也有一个可选的第二个上下文参数。MDN对.some的形貌以下：
some将会给数组里的每一个元素实行一遍回调函数，直到回调函数返回true。假如找到目的元素，some马上返回true，不然some返回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注重，当回调函数的value < 10时，中缀函数轮回。.every的运转道理和.some相似，但回调函数是返回false而不是true。
辨别.join和.concat
.join和.concat 常常殽杂。.join(separator)以separator作为分隔符拼接数组元素，并返回字符串情势，假如没有供应separator，将运用默许的,。.concat会建立一个新数组，作为源数组的浅拷贝。
.concat经常使用用法：array.concat(val, val2, val3, valn)
.concat返回一个新数组
array.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栈和行列的完成：.pop, .push, .shift和 .unshift
每一个人都晓得.push能够再数组末端增加元素，然则你晓得能够运用[].push(‘a’, ‘b’, ‘c’, ‘d’, ‘z’)一次性增加多个元素吗？
.pop 要领是.push 的反操纵，它返回被删除的数组末端元素。假如数组为空，将返回void 0 (undefined),运用.pop和.push能够建立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
相反，能够运用.shift和 .unshift建立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
Using .shift (or .pop) is an easy way to loop through a set of array elements, while draining the array in the process.
list = [1,2,3,4,5,6,7,8,9,10]
while (item = list.shift()) {
console.log(item)
}
list
// <- []模子映照：.map
.map为数组中的每一个元素供应了一个回调要领，并返回有挪用效果构成的新数组。回调函数只对已指定值的数组索引实行；它不会对已删除的或未指定值的元素挪用。
Array.prototype.map 和上面提到的.forEach、.some和 .every有雷同的参数花样：.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不会对已删除的或未指定值的元素挪用，但仍然会被包括在效果数组中。.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)
}
})查询：.filter
filter对每一个数组元素实行一次回调函数，并返回一个由回调函数返回true的元素构成的新数组。回调函数只会对已指定值的数组项挪用。
通经常使用法：.filter(fn(value, index, array), thisArgument),跟C#中的LINQ表达式和SQL中的where语句相似，.filter只返回在回调函数中返回true值的元素。
[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, '']排序：.sort(compareFunction)
假如没有供应compareFunction，元素会被转换成字符串并根据字典排序。比方，”80″排在”9″之前，而不是在厥后。
跟大多数排序函数相似，Array.prototype.sort(fn(a,b))须要一个包括两个测试参数的回调函数,其返回值以下：
a在b之前则返回值小于0
a和b相称则返回值是0
a在b以后则返回值小于0
[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]盘算：.reduce和.reduceRight
这两个函数比较难明白，.reduce会从左往右遍历数组，而.reduceRight则从右往左遍历数组，两者典范用法：.reduce(callback(previousValue,currentValue, index, array), initialValue)。
previousValue 是末了一次挪用回调函数的返回值，initialValue则是其初始值，currentValue是当前元素值，index是当前元素索引，array是挪用.reduce的数组。
一个典范的用例，运用.reduce的乞降函数。
Array.prototype.sum = function () {
return this.reduce(function (partial, value) {
return partial + value
}, 0)
};
[3,4,5,6,10].sum()
// <- 28假如想把数组拼接成一个字符串，能够用.join完成。然则，若数组值是对象，.join就不会根据我们的希冀返回值了，除非对象有合理的valueOf或toString要领，在这类状况下，能够用.reduce完成：
function concat (input) {
return input.reduce(function (partial, value) {
if (partial) {
partial += ', '
}
return partial + value
}, '')
}
concat([
{ name: 'George' },
{ name: 'Sam' },
{ name: 'Pear' }
])
// <- 'George, Sam, Pear'复制：.slice
和.concat相似，挪用没有参数的.slice()要领会返回源数组的一个浅拷贝。.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 }]别的，.slice的另一个通经常使用法是从一个参数列表中删除一些元素，这能够将类数组对象转换为真正的数组。
function format (text, bold) {
if (bold) {
text = '<b>' + text + '</b>'
}
var values = Array.prototype.slice.call(arguments, 2)
values.forEach(function (value) {
text = text.replace('%s', value)
})
return text
}
format('some%sthing%s %s', true, 'some', 'other', 'things')壮大的.splice
.splice 是我最喜欢的原生数组函数，只须要挪用一次，就许可你删除元素、插进去新的元素，并能同时举行删除、插进去操纵。须要注重的是，差别于`.concat和.slice,这个函数会转变源数组。
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]正如你看到的，.splice会返回删除的元素。假如你想遍历已删除的数组时，这会异常轻易。
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]查找：.indexOf
应用.indexOf 能够在数组中查找一个元素的位置，没有婚配元素则返回-1。我常常运用.indexOf的状况是当我有比较时，比方：a === ‘a’ || a === ‘b’ || a === ‘c’，或许只要两个比较，此时，能够运用.indexOf：[‘a’, ‘b’, ‘c’].indexOf(a) !== -1。
注重，假如供应的援用雷同，.indexOf也能查找对象。第二个可选参数用于指定最先查找的位置。
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。
操纵符：in
在口试中新手轻易犯的毛病是殽杂.indexOf和in操纵符:
var a = [1, 2, 5]
1 in a
// <- true, but because of the 2!
5 in a
// <- false问题是in操纵符是检索对象的键而非值。固然，这在性能上比.indexOf快得多。
var a = [3, 7, 6]
1 in a === !!a[1]
// <- true走近.reverse
该要领将数组中的元素颠倒。
var a = [1, 1, 7, 8]
a.reverse()
// [8, 7, 1, 1].reverse 会修正数组自身。
