数组Array.join()方法将数组中所有元素都转化为字符串并拼接在一起，返回最后生成的字符串。可以指定一个可选的字符

数组方法

改变数组本身：reverse()、sort()、splice()、push()、pop()、unshift()、shift()

返回新数组：join()、concat()、slice()、toString()

join()

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

var a = [a, b, c]
a.join() // "a,b,c"
a.join(" ") // "a b c"
a.join("") // "abc"
var b = new Array(8) // 创建长度为8的空数组
b.join("-") // "-------" 7个字符串组成

reverse()

Array.reverse()方法将数组中的元素颠倒顺序，返回逆序数组。（注意：不是通过重新排列的元素创建新的数组，而是在原先的数组中重新排列他们）

var a = [a, b, c]
a.reverse() // a=>[c, b, a]

sort()

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

var a = [b, a, c]
a.sort() // a=> [a, b, c]

如果数组中包含undefined元素，它们会被排到数组的尾部。

如果想按照其他方式而非字母表顺序进行排序，必须给sort()方法传递一个比较函数。该函数决定了他的两个参数在排好序的数组中的先后顺序。假设第一个参数应该在前，比较函数应该返回一个小于0的数值。反之，假设第一个参数应该在后，函数应该返回一个大于0的数值。并且，假设两个值相等，函数应该返回0。

按照数值大小排列：

var a = [34, 4, 23, 111, 6]
a.sort() // a=>[111, 23, 34, 4, 6]
a.sort(funtion(a, b) {
    // a 为数组列表中后一个 b为前一个 a: 4  b:34
    return a-b
}) // a=>[4, 6, 23, 34, 111]
a.sort(funtion(a, b) {
    return b-a
}) // a=>[111, 34, 23, 6, 4]

字符串按照不区分大小写大小排列：

var a = ['cat', 'Bug', 'ant', 'Dog']
a.sort() // 区分大小写的排列： ['Bug', 'Dog', 'ant', 'cat']
a.sort(function(a, b) {
    let m = a.toLowerCase()
    let n = b.toLowerCase()
    if (m < n) { return -1 }
    if (m > n) { return 1 }
    return 0
}) // a=>['ant', 'Bug', 'cat', 'Dog']

concat()

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

let a = [1, 2, 3]
a.concat(4, 5) // [1, 2, 3, 4, 5]
a.cancat([4, 5]) // [1, 2, 3, 4, 5]
a.concat([4, 5], [6, 7]) // [1, 2, 3, 4, 5, 6, 7]
a.concat(4, [5, [6, 7]]) // [1, 2, 3, 4, 5, [6, 7]]

slice()

Array.slice()方法返回指定数组的一个片段或子数组。它的两个参数分别指定了片段的开始和结束的位置。返回的数组包含第一个参数指定的位置和所有到但不包含第二个参数指定的位置之间的所有数组元素。如果只制定一个参数，返回的数组将包含从开始位置到数组结束的所有元素。如参数中出现负数，它表示相对应数组的最后一个元素的位置（如参数-1为最后一个元素，-3为倒数第三个元素）。（注意：slice()不会修改调用的数组）。

let a = [1, 2, 3, 4, 5]
a.slice(0, 3) // [1, 2, 3]
a.slice(3) // [4, 5]
a.slice(1, -1) // [2, 3, 4]
a.slice(-3, -2) // [3]

splice()

Array.splice()方法是在数组中插入或删除元素的通用方法。不同于slice()和从cancat(),splice()会修改调用的数组。

splice()能够从数组中删除元素、插入元素到数组中或者同时完成这两种操作。在插入或删除点之后的数组元素会根据需要增加或减小它们的索引值，因此数组的其他部分仍然保持连续。splice()的第一个参数指定了插入和删除的起始位置。第二个参数指定了应该从数组中删除的元素个数。如果省略第二个参数，从起始点开始到数组结尾的所有元素都被删除。splice()返回一个由删除元素组成的数组，或者如果没有删除元素就返回一个空数组。

let a = [1, 2, 3, 4, 5, 6, 7, 8]
a.splice(4) // 返回[5, 6, 7, 8] a=>[1, 2, 3, 4]
a.splice(1, 2) // 返回[2, 3] a=>[1, 4, 5, 6, 7, 8]

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

let a = [1, 2, 3, 4, 5, 6, 7, 8]
a.splice(2, 0, 'a', 'b') // 返回[] a=>[1, 2, "a", "b", 3, 4, 5, 6, 7, 8]
a.splice(2, 2, [1, 2], 3) // 返回['a', 'b'] a=> [1, 2, [1, 2], 3, 3, 4, 5, 6, 7, 8]

push()和pop()

push()和pop()方法允许将数组当做栈来使用。push()方法在数组的尾部添加一个或者多个元素，并返回数组新的长度。pop()方法则相反：它删除数组的最后一个元素，减小数组长度并返回它删除的值。注意：两个方法都修改并替换原始数组而非生成一个修改版的新数组。组合使用push()和pop()能够用JS数组实现先进后出的栈。

var a = []
a.push(1, 2) // a=>[1,2]
a.pop() // a=>[1] 返回2

unshift()和shift()

unshift()和shift()方法的行为非常类似于push()和pop()，不一样的是前者是在数组的头部而费尾部进行元素的插入和删除操作。unshift()在数组的头部添加一个或多个元素，并将已存在的元素移动到更高索引的位置来获得足够的空间，最后返回数组新的长度。shift()删除数组的第一个元素并将其返回，然后把所有随后的元素下移一个位置。

注意：当使用多个参数调用unshift()时它的行为令人惊讶。参数是一次性插入的（就像splice()方法）而非一次一个地插入。这意味着最终的数组中插入的元素的顺序和它们在参数列表中的顺序一致。

toString()和toLocaleString()

数组和其他JS对象一样拥有toString()方法。针对数组，该方法将其每个元素转化为字符串（如有必要将调用元素的toString()方法）并且输出用逗号分割的字符串列表。

[1, 2, 3].toString() // "1,2,3" 这里与不适用任何参数调用join()方法返回的字符串是一样的。

在以下的数组方法中，大多数方法的第一个参数接受一个函数，并对数组的每个元素调用一次该函数。在大多数情况下，调用提供的函数使用三个参数：数组元素、元素的索引、数组本身。大多数数组方法的第一个参数是一个函数，第二个参数是可选的。如果有第二个参数则调用的函数被看做是第二个参数的方法。注意：以下数组方法不会修改调用的数组，当然传递给这些方法的函数是可以修改这些数组的。

forEach()

forEach()遍历数组，为每个元素调用指定的函数。

var a = [1, 2, 3, 4, 5, 6, 7, 8]
a.forEach(item => {
	item = item+1
}) // a不变 不会改变被调用的数组
a.forEach((item, i, a) => {
	a[i] = item + 1
}) // a=>[2, 3, 4, 5, 6, 7, 8, 9]

注意：forEach()无法在所有元素都传递给调用的函数之前终止遍历。也就是说，没有像for循环中使用的响应的break语句。

map()

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

注意：传递给map()的函数的调用方法和传递给forEach()的函数调用方式一样。但传递给map()的函数应该有返回值。map()返回的是新数组：不修改调用的数组。

var a = [1, 2, 3, 4, 5, 6, 7, 8]
var b = a.map((item) => {
	return item = item + 1
}) // b => [2, 3, 4, 5, 6, 7, 8, 9] a=>[1, 2, 3, 4, 5, 6, 7, 8]

filter()

filter()方法返回的数组元素是调用的数组的一个自己。传递的函数是用来逻辑判断的，该函数返回true或者false以此来判断是否添加到一个作为返回值的数组中。

var a = [1, 2, 3, 4, 5, 6, 7, 8]
var b = a.filter((item) => {
	return item < 3
})// b =>[1, 2]

every()和some()

every()和some()是数组的逻辑判定：它们对数组元素应用指定的函数进行判定，返回true和false。

every()方法就像是数学中的"针对所有"：当且仅当数组中的所有元素调用判定函数都返回true，才会返回true。

var a = [1, 2, 3, 4, 5, 6, 7, 8]
var b = a.every((item) => {
	return item < 3
}) // b=>false

some()方法就像是数学中的"存在"：当数组中至少有一个元素调用判定函数返回true，就会返回true；并且当且仅当数组中的所有元素调用判定函数都返回false，才会返回false。

var a = [1, 2, 3, 4, 5, 6, 7, 8]
var b = a.some((item) => {
	return item < 3
}) // b => true

注意：一旦every()和some()确定该返回什么值就会停止遍历数组元素。

reduce()和reduceRight()

reduce()和reduceRight()方法使用指定函数将数组元素进行组合，生成单个值。

reduce()需要两个参数。第一个是执行化简操作的函数。化简函数的任务就是使用某种方法将两个值组合或化简为一个值，并返回化简后的值。第二个是传递给函数的初始值。(reduceRight则是反方向）

var a = [1, 2, 3, 4, 5, 6, 7, 8]
var b = a.reduce((x, y) => {
	return x+y
}) // b => 36

indexOf()和lastIndexOf()

indexOf()和lastIndex()搜索整个数组中具有给定值的元素，返回找到的第一个元素的索引或没有找到就返回-1.indexOf从头至尾搜索，而lastIndexOf()则是反方向搜索。

var a = [1, 2, 3, 4, 5, 6, 7, 8]
var b = a.indexOf(1) // b=>0

数组类型

Array.isArray()

Array.isArray([]) // => true
Array.isArray({}) // => false