废话不多说，直接进入主题！

创建数组

字面量

数组字面量是平时用得最多的，最简单的创建方式。

let arr1 = []
let arr2 = [1, 2, 3]
console.log(arr1)   // []
console.log(arr2)   // (3) [1, 2, 3]

构造函数

利用构造函数创建数组，参数类型不同，返回的结果也不同。

let arr1 = new Array()
let arr2 = Array()
let arr3 = Array(2)
let arr4 = Array(1, 2)
let arr5 = Array('1', '2')

console.log(arr1)   // []
console.log(arr2)   // []
console.log(arr3)   // (2) [empty × 2]
console.log(arr4)   // (2) [1, 2]
console.log(arr5)   // (2) ["1", "2"]

Array.from()

Array.from() 方法从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。
返回一个新的数组实例。

let arr1 = Array.from('LqZww')
console.log(arr1)   // (5) ["L", "q", "Z", "w", "w"]

let obj = {
  0: 'h',
  1: 'i',
  length: 2
}
let arr2 = Array.from(obj)
console.log(arr2)   // (2) ["h", "i"]
console.log(arr2 instanceof Array)    // true

Array.of

Array.of() 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。

此方法解决了利用构造函数创建数组的缺陷。

Array.of(5) 会创建一个具有单个元素 5 的数组，而 Array(5) 会创建一个长度为 5 的空数组。

let arr1 = Array.of()
let arr2 = Array.of(3)

console.log(arr1)   // []
console.log(arr2)   // [3]

检测数组

Array.isArray()

Array.isArray() 用于确定传递的值是否是一个 Array。

let arr = [1, 2, 3]
let obj = {
  0: 'h',
  1: 'i',
  length: 2
}

console.log(Array.isArray(arr))   // true
console.log(Array.isArray(obj))   // false

注意：当检测 Array 实例时, Array.isArray 优于 instanceof,因为 Array.isArray 能检测 iframes。

数组方法

不改变原数组

concat()

concat() 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。

let arr1 = [1, 2, 3]
let arr2 = [4, 5, 6]
let arr3 = arr1.concat(arr2)
console.log(arr1)   // [1, 2, 3]
console.log(arr2)   // [4, 5, 6]
console.log(arr3)   // [1, 2, 3, 4, 5, 6]

join()

join() 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。

let arr = [1, 2, 3]
let res = null
res = arr.join()
console.log(arr)    // [1, 2, 3]
console.log(res)    // 1,2,3

slice()

slice() 方法返回一个新的被提取元素的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括 end）。原始数组不会被改变。

let arr = [1, 2, 3]
let res = null
res = arr.slice(1, 3)
console.log(arr)    // [1, 2, 3]
console.log(res)    // [2, 3]

indexOf()

indexOf() 方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。

let arr = [1, 2, 3]
let res1 = arr.indexOf(3)
let res2 = arr.indexOf(4)
console.log(arr)    // [1, 2, 3]
console.log(res1)   // 2
console.log(res2)   // -1

lastIndexOf()

lastIndexOf() 方法返回指定元素在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找。

let arr = [1, 2, 3, 1]
let res = null
res = arr.lastIndexOf(1)
console.log(arr)    // [1, 2, 3, 1]
console.log(res)    // 3

toString()

toString() 返回一个字符串，表示指定的数组及其元素。

let arr = [1, 2, 3]
let res = null
res = arr.toString()
console.log(arr)    // [1, 2, 3]
console.log(res)    // 1,2,3

改变原数组

pop()

pop() 方法从数组中删除最后一个元素，并返回被删除元素的值。此方法更改数组的长度。该方法会改变原数组。

let arr = [1, 2, 3]
let res = null
res = arr.pop()
console.log(arr)    // [1, 2]
console.log(res)    // 3

push()

push() 方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。该方法会改变原数组。

let arr = [1, 2, 3]
let res = null
res = arr.push(4, 5, 6)
console.log(arr)    // [1, 2, 3, 4, 5, 6]
console.log(res)    // 6

shift()

shift() 方法从数组中删除第一个元素，并返回该被删除元素的值。此方法更改数组的长度。该方法会改变原数组。

let arr = [1, 2, 3]
let res = null
res = arr.shift()
console.log(arr)    // [2, 3]
console.log(res)    // 1

unshift()

unshift() 方法将一个或多个元素添加到数组的开头，并返回该数组的新长度。该方法会改变原数组。

let arr = [1, 2, 3]
let res = null
res = arr.unshift(4)
console.log(arr)    // [4, 1, 2, 3]
console.log(res)    // 4

reverse()

reverse() 方法将数组中元素的位置颠倒，并返回该数组。该方法会改变原数组。

let arr = [1, 2, 3]
let res = null
res = arr.reverse()
console.log(arr)    // [3, 2, 1]
console.log(res)    // [3, 2, 1]

sort()

sort() 方法用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的 UTF-16 代码单元值序列时构建的。该方法会改变原数组。

let arr = [2, 1, 4, 3]
let res = null
res = arr.sort()
console.log(arr)    // [1, 2, 3, 4]
console.log(res)    // [1, 2, 3, 4]

let arr = [2, 1, 4, 3]
let res = null
res = arr.sort(function(a, b) {
  return a - b
})
console.log(arr)    // [1, 2, 3, 4]
console.log(res)    // [1, 2, 3, 4]

let arr = [2, 1, 4, 3]
let res = null
res = arr.sort(function(a, b) {
  return b - a
})
console.log(arr)    // [4, 3, 2, 1]
console.log(res)    // [4, 3, 2, 1]

splice()

splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。

// 删除元素
let arr = [2, 1, 4, 3]
let res = null
res = arr.splice(1, 2)
console.log(arr)    // [2, 3]
console.log(res)    // [1, 4]

// 删除所有元素
let arr = [2, 1, 4, 3]
let res = null
res = arr.splice(0)
console.log(arr)    // []
console.log(res)    // [2, 1, 4, 3]

// 删除并添加元素
let arr = [2, 1, 4, 3]
let res = null
res = arr.splice(1, 2, 9)
console.log(arr)    // [2, 9, 3]
console.log(res)    // [1, 4]

遍历

forEach()

forEach() 方法对数组的每个元素执行一次给定的函数。返回 undefined。

let arr = [2, 1, 4, 3]
let res = null
res = arr.forEach(function(value, index) {
  arr[index] += 1
})
console.log(arr)    // [3, 2, 5, 4]
console.log(res)    // undefined

map()

map() 方法创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。

let arr = [2, 1, 4, 3]
let res = null
res = arr.map(function(value, index) {
  return value += 1
})
console.log(arr)    // [2, 1, 4, 3]
console.log(res)    // [3, 2, 5, 4]

every()

every() 方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。该方法不改变原数组。

let arr = [2, 1, 4, 3]
let res = null
res = arr.every(function(value) {
  return value > 0
})
console.log(arr)    // [2, 1, 4, 3]
console.log(res)    // true

some()

some() 方法测试数组中是不是至少有 1 个元素通过了被提供的函数测试。它返回的是一个 Boolean 类型的值。该方法不改变原数组。

let arr = [2, 1, 4, 3]
let res = null
res = arr.some(function(value) {
  return value > 3
})
console.log(arr)    // [2, 1, 4, 3]
console.log(res)    // true

filter()

filter() 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。该方法不改变原数组。

let arr = [2, 1, 4, 3]
let res = null
res = arr.filter(function(value) {
  return value > 2
})
console.log(arr)    // [2, 1, 4, 3]
console.log(res)    // [4, 3]

reduce()

reduce() 方法对数组中的每个元素执行一个由您提供的 reducer 函数(升序执行)，将其结果汇总为单个返回值。该方法不改变原数组。

let arr = [1, 2, 3]
let sum = arr.reduce(function(a, b) {
  return a + b;
}, 0);
console.log(arr)    // [1, 2, 3]
console.log(sum)    // 6

reduceRight()

reduceRight() 方法接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。该方法不改变原数组。

let arr = [[0, 1],[2, 3],[4, 5]]
let res = arr.reduceRight(function(a, b) {
  return a.concat(b)
});
console.log(arr)    // [Array(2), Array(2), Array(2)]
console.log(res)    // [4, 5, 2, 3, 0, 1]