js数组常用方法

join

Array.join()方法将数组中所有元素都转化为字符串并连接在一起，返回最后生成的字符串。可以指定一个可选的字符串在生成的字符串中来分隔数组的各个元素。如果不指定分隔符，默认使用逗号。示例：

var a = [1,2,3]
console.log(a.join()) //1,2,3
console.log(a.join(" ")) //1 2 3
console.log(a.join(""))//123

reverse

Array.reverse()方法将数组中的元素颠倒顺序，返回逆序的数组。它采取了替换；即在原先的数组中重新排列它们。示例：

var a = [1,2,3]
console.log(a.reverse().join()) //3,2,1

sort

Array.sort()方法将数组中的元素排序并返回排序后的数组。当不带参数调用sort()时，数组元素以字母表顺序排序（如有必要将临时转化为字符串进行比较）：

var a = ['d','b','c']
console.log(a.sort().join()) //b,c,d

如果数组包含undefined元素，将会被安排到数组的尾部。
sort方法可以传一个比较函数用于非字母排序，该函数接收两个参数，假设第一个参数应该在前，比较函数应该返回一个小于0的数值，反之，第一个参数在后，返回一个大于0的数值，示例：

var a = [3,26,5,2]
a.sort(function (a,b) {
  if (a<b) {
     return -1
  } else {
    return 1
  }
})
console.log(a.join()) //2,3,5,26

concat

Array.concat()方法创建并返回一个新数组，它的元素包括调用concat()的原始数组的元素和concat()的每个参数。如果参数中的任何一个自身是数组，则连接的是数组的元素，而非数组本身，concat()不会递归扁平化数组，也不会修改调用数组。示例：

var a = [1,2,3]
console.log(a.concat(4, 5)) // [ 1, 2, 3, 4, 5 ]
console.log(a.concat([4, 5])) // [ 1, 2, 3, 4, 5 ]

slice

Array.slice()方法返回指定数组的一个片段或子数组。它的两个参数分别指定了片段的开始和结束的位置。返回的数组包含第一个参数位置但不含第二个参数位置之间的元素，如果只有一个参数，则返回开始位置到数组结尾的所有元素。如参数中出现负数，表示相对于数组中最后一个元素的位置。示例：

var a = [1,2,3,4]
console.log(a.slice(0,2)) //[1, 2]
console.log(a.slice(2)) //[3, 4]
console.log(a.slice(-2,-1)) //[3]

splice

Array.splice()方法是在数组中插入或删除元素的方法，会修改调用的数组。
第一个参数指定了插入或删除的起始位置。第二个参数指定了应该从数组中删除的元素个数。如果省略第二个参数，从起点开始到数组结尾的所有元素都将被删除。splice()返回一个由删除元素组成的数组。示例：

var a = [1,2,3,4]
console.log(a.splice(3)) // [4]
console.log(a.splice(1,2)) // [2, 3]

splice()的前两个参数指定了需要删除的数组元素。紧随其后的任意个数的参数指定了需要插入到数组中的元素，从第一个参数指定的位置开始插入。例如：

var a = [1,2,3,4]
a.splice(2,0,'a','b')
console.log(a) // [ 1, 2, 'a', 'b', 3, 4 ]
a.splice(2,2,[1,2],3)
console.log(a) // [ 1, 2, [ 1, 2 ], 3, 3, 4 ]

push和pop

push()和pop()方法允许将数组当作栈来使用。push()方法在数组的尾部添加一个或多个元素，并返回数组新的长度。pop()方法则相反：它删除数组的最后一个元素，减小数组长度并返回删除的值。两个方法都修改并替换原始数组而非生成一个修改版的新数组。示例：

var a = [1,2,3,4]
a.push(5)
console.log(a) //[ 1, 2, 3, 4, 5 ]
a.pop()
console.log(a) //[ 1, 2, 3, 4 ]

unshift和shift

unshift()和shift()方法的行为非常类似于push()和pop()，不一样的是shift和unshift对数组的第一个元素进行删除和插入操作

var a = []
a.unshift(2)
console.log(a) //[2]
a.unshift(3)
console.log(a) //[3,2]
a.shift()
console.log(a) //[2]

forEach

forEach()方法从头到尾遍历数组，为每个元素调用指定的函数，该函数接收三个值：数组元素、元素的索引、和数组本身。如果只关心数组元素的值，可以只传一个值。示例：

var a = [1,2,3,4]
var sum = 0;
a.forEach(function (val) {
  sum += val
})
console.log(sum) //10
a.forEach(function (v, i, s) {
  s[i] = v + 1
})
console.log(a) //[ 2, 3, 4, 5 ]

map

map()方法将调用的数组的每个元素传递给指定的函数，并返回一个数组，它包含该函数的返回值。示例：

var a = [1,2,3,4]
b = a.map(function (val) {
  return val * val
})
console.log(b) //[ 1, 4, 9, 16 ]

Tips: map()返回的是新数组：它不修改调用的数组

filter

filter()方法返回的数组元素是调用的数组的一个子集。传递的函数是用来逻辑判定的，函数如果返回值是true，那么传递给判定函数的元素就是这个子集的成员。示例：

var a = [1,2,3,4]
var b = a.filter(function (x) {
  return x<3
})
console.log(b) //[1, 2]

every和some

every()和some()方法是数组的逻辑判定：它们对数组元素应用指定的函数进行判定，返回true和false
every()方法当且仅当数组中的所有元素调用判定函数都返回true，才返回true：

var a = [1,2,3,4]
console.log(
  a.every(function (x) {
  return x < 5
})) //true

some()方法当数组中至少有一个元素判定函数返回true，它就返回true;并且当且仅当数组中的所有元素调用判定函数都返回false，才返回false

var a = [1,2,3,4]
console.log(
  a.some(function (x) {
  return x < 2
})) //true
console.log(a.some(isNaN)) //false

Tips:一旦every()和some()确认该返回什么值时它们就会停止遍历元素

reduce和reduceRight

reduce()和reduceRight()方法使用指定的函数将元素进行组合，生成单个值。可以称为“注入”和“折叠”。示例：

var a = [1,2,3,4]
var sum = a.reduce(function (x, y) {
  return x+y
},3)
console.log(sum) //13
var max = a.reduce(function (x,y) {
  return (x>y)?x:y
})
console.log(max) //4

reduce()需要两个参数。第一个执行化简操作的函数。化简函数的任务就是用某种方法把两个值组合或化简为一个值，并返回化简后的值。
在空数组上，不带初始值参数调用reduce()将导致类型错误异常。如果调用它的时候只有一个值，数组只有一个元素并且没有指定初始值，或者有一个空数组并且指定一个初始值，reduce()只是简单地返回那个值而不会调用简化函数。
reduceRight()的工作原理和reduce()一样，不同的是它按照数组索引从高到底（从右到左）处理数组，而不是从低到高

indexOf和lastIndexOf

indexOf()和lastIndexOf()搜索整个数组中具有给定值的元素，返回找到的第一个元素的索引或者如果没有找到就返回-1。indexOf()从头到尾搜索，而lastIndexOf()则反向搜索。示例：

var a = [0,1,2,1,0]
console.log(a.indexOf(1)) //1
console.log(a.lastIndexOf(1)) //3
console.log(a.indexOf(3)) //-1

indexOf()和lastIndexOf()方法不接收一个函数作为其参数，第一个参数是需要搜索的值，第二个参数是可选的：它指定数组的一个索引，从指定位置开始搜索。如果省略该参数，indexOf()从头开始搜索，而lastIndexOf()从末尾开始搜索。