数组方法汇总

Array.flat()：扁平化数组的方法（数组内的数组展开）。
Array.flatMap()：遍历数组，并返回扁平化的数组。
Array.toLocaleString()：把数组转化为特定环境的一个字符串。
Array[Symbol.iterator] ()：类似Aarry.values()的迭代器。
Array[Symbol.species]：返回默认的构造函数。

1、Array.from() ：将参数拆分为一个数组内的各个元素。（IE不兼容）

>console.log(Array.from('foo'))  
Array['f','o','o']
console.log(Array.from([1,2,3], x => x + x))
>Array[2,3,4]

注意：参数也可以是 set map数据结构的数据。拿到处理后的数组。

2、Array.isArray()：判断是否为数组
Array.isArray([1,2,3]) // true

3、Array.of()：把传入值组成一个数组。（IE不兼容）

Array.of(1,2,3) // [1,2,3]

参数：要创建的数组元素
返回值：一个新数组。

4、Array.concat()：用于合并两个或多个数组。

var arr1 = [1, 2]
var arr2 = ['a', 'b']
var arr3 = [3, 'c']
console.log(arr1.concar(arr2, arr3)))
>[1, 2, 'a', 'b', 3, 'c']

参数：要加入的其他数组
返回值：一个新数组

注意：这是一个浅拷贝。拷贝原始数组的引用（原始数组改变 也会改变该合并数组）

5、Array.copyWithin()：将数组中一部分内容复制到其他位置，最后返回它而不改变其长度。(覆盖原位置的值)

var arr1 = [1, 2, 3, 4, 5]
console.log(arr.copyWithin(0, 3, 4)) // 参数1：被复制的位置；参数二三：复制的起始位置。
>[4, 2, 3, 4, 5]

参数：参数1：被复制的位置；参数二三：复制的起始位置。
返回值：被修改后的原数组。

6、Array.entries()：获取数组中的索引的键值对。（IE不兼容）

var arr1 = ['a', 'b', 'c']
for (let v of arr1.entries()) {
    console.log(v)
}
>[0, 'a']
 [1, 'b']
 [2, 'c']

返回值：新的Array Iterator对象。多用于在for…of中遍历获取。

Aarry.keys()：获取数组中的索引的键。

var arr1 = ['a', 'b', 'c']
for (let v of arr1.keys()) {
    console.log(v)
}
>0, 1, 2

返回值：新的Array Iterator对象。多用于在for…of中遍历获取。

Aarry.values()：获取数组中每个索引的值。

var arr1 = ['a', 'b', 'c']
for (let v of arr1.values()) {
    console.log(v)
}
>'a', 'b', 'c'

返回值：新的Array Iterator对象。多用于在for…of中遍历获取。

7、Array.every()：判断数组中的所有元素是否符合所提供函数的条件。（IE不兼容）

var arr1 = [4, 5, 6]
arr1.every(x => x > 3) // true

参数：测试函数，（this执行时使用的callback）
返回值：布尔值。

Array.some()：判断数组中的是否 至少有一个元素符合所提供函数的条件。

var arr1 = [4, 5, 6]
arr1.some(x => x > 5) // true

参数：测试函数，（this执行时使用的callback）
返回值：布尔值。

8、Array.fill()：用静态值填充某一段区间的值。 （IE不兼容）

var arr1 = [1, 2, 3]
arr1.fill(0, 1)
// [1, 0, 0]

参数：参数1：填充的静态值；参数二三：被填充的起始位置。
返回值：被修改后的原数组。

9、Array.filter()：获取数组中所有符合函数中条件的值组成的数组。

var arr1 = [1, 2, 3, 4, 5, 6]
arr1.filter(x => x > 3)
//[4, 5, 6]

参数：要满足条件的函数，（this执行时使用的callback）
返回值：符合条件的 新数组。

10、Array.find()：返回数组中第一个符合条件的值，否则返回undefind。（IE不兼容）

var arr1 = [1, 2, 3, 4]
arr1.find(function(x) {
    return x>2 // 注意使用{}时，要用return（直接使用 单个语句的箭头函数不用return）
})
// 3

参数：要满足条件的函数，…
返回值：第一个符合条件的 值。

11、Array.findIndex()：返回数组中第一个符合条件值的索引，否则返回-1。（IE不兼容）

var arr1 = [1, 2, 3, 4]
arr1.find(function(x) {
    return x>2 // 注意使用function时，要用return（直接使用 单个语句的箭头函数不用return）
})
// 2

参数：要满足条件的函数，…
返回值：第一个符合条件值得索引。

12、Array.forEach()：对每个数组元素都执行一次提供的函数。

var arr1 = [1, 2, 3, 4]
arr1.forEach(function(x) {
    console.log(x)
})
//1, 2, 3, 4

参数：要执行的函数，…
返回值：undefined。

Array.map()：遍历数组每个元素 执行提供函数，并返回操作结果值组成的新数组。

var arr1 = [1, 2, 3]
var arr2 = arr1.map(function() {
    return x*2
})
console.log(arr2)
>[2, 4, 6]

参数：要执行的函数，…
返回值：执行回调后的新数组。

13、Array.includes()：判断某个元素是否在该数组内。

var arr1 = ['a', 'b', 'c']
arr1.includes('b')
// true

参数：参数1：要判断的值；参数2：搜索的起始位置（默认0）。
返回值：布尔值。

14、Array.indexOf()：获取搜索元素在数组中的第一个索引，没有返回-1。

var arr1 = ['a', 'b', 'c', 'b']
arr1.indexOf('b')
// 1

参数：参数1：要搜索的值；参数2：搜索的起始位置（默认0）。
返回值：索引 数字。

Array.lastIndexOf()：获取搜索元素在数组中的 最后一个索引，没有返回-1。

var arr1 = ['a', 'b', 'c', 'b']
arr1.lastIndexOf('b')
// 3

参数：参数1：要搜索的值；参数2：搜索的起始位置（默认0）。
返回值：索引 数字。

15、Array.join()：通过指定字符（默认逗号）把数组元素连成一个字符串并返回。

var arr1 = ['a', 'b', 'c']
arr1.join()
// "a, b, c"

参数：元素之间指定的连接符（默认逗号）
返回值：连接后的字符串。

16、Array.pop()：把数组 最后一个元素删除，并返回该元素。

var arr1 = ['a', 'b', 'c']
var lastElement = arr1.pop()
console.log(arr1)  // ['a', 'b']
console.log(lastElement)  // 'c'

返回值：被删除的元素值，空数组返回undefined。（改变原数组）

Array.shift()：把数组 第一个元素删除，并返回该元素。

var arr1 = ['a', 'b', 'c']
var firstElement = arr1.shift()
console.log(arr1)  // ['b', 'c']
console.log(firstElement)  // 'a'

返回值：被删除的元素值，空数组返回undefined。（改变原数组）

17、Array.push()：将一个或者多个元素添加到数组末尾，并返回数组的最新长度。

var arr1 = ['a', 'b', 'c']
var size = arr1.push('d', 'e')
console.log(arr1)  // ['a', 'b', 'c', 'd', 'e']
console.log(size)  // 5

参数：要添加的一个或者多个元素。
返回值：数组新长度。（改变原数组）

Array.unshift()：将一个或者多个元素添加到数组开头，并返回数组的最新长度。

var arr1 = ['a', 'b', 'c']
var size = arr1.unshift('d', 'e')
console.log(arr1)  // ['d', 'e', 'a', 'b', 'c']
console.log(size)  // 5

参数：要添加的一个或者多个元素。
返回值：数组新长度。（改变原数组）

18、Array.reduce()：遍历数组 执行提供的函数，每次都返回值给一个累积器，最后返回该值。

var arr1 = [1, 2, 3, 4]
var total = arr1.reduce(funtion(accumulator, currentValue) => {
    return accumulator + currentValue
}, 2)
// 12 (2+1+2+3+4)

参数：提供函数（参数1：累积器accumulator，参数2：遍历当前值，参数3：遍历当前值得索引， 参数4：该数组），
累积器accumulator的初始值（没有则使用第一个元素）。
返回值：累积器accumulator最终值。

Array.reduceRight()：从右到左 遍历数组 执行提供的函数，每次都返回值给一个累积器，最后返回该值。（reduce是从左到右）

var arr2 = [[0, 1], [2, 3], [4, 5]].reduceRight((accumulator, currentValue) => {
    accumulator.concat(currentValue)
})
console.log(arr2)
>[4, 5, 2, 3, 0, 1]

参数：提供函数（参数1：累积器accumulator，参数2：遍历当前值，参数3：遍历当前值得索引， 参数4：该数组），
累积器accumulator的初始值（没有则使用 最后一个元素）。
返回值：累积器accumulator最终值。

19、Array.reverse()：反转数组，倒叙重排。

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

返回值：倒叙重排后的数组。（改变原数组）

20、Array.slice()：截取数组中的一部分，并返回这个新数组。

var arr1 = ['a', 'b', 'c', 'd']
var arr2 = arr1.slice(1, 3)
console.log(arr2)
>['b', 'c']

参数：参数1：开始截取索引（包括）；参数2：结束截取索引（不包括，省略时默认到最后）。
返回值：截取的新数组。（不改变原数组）

21、Array.sort()：对数组元素进行排序。

var arr1 = [1, 30, 4, 21, 100000]
arr1.sort()
console.log(arr1)
>[1, 100000, 21, 30, 4]  // 按照utf-16序列排序
arr1.sort(function(a, b) {
    return a - b
})
console.log(arr1)
>[1, 4, 21, 30, 100000]  // 比价大小，小的在前

参数：定义排序的函数。默认顺序是将元素转化成字符串，然后比较他们的UTF-16代码单元值序列。
返回值：排序后的数组。（改变原数组）

22、Array.splice()：在数组上删除或添加新的元素。

var arr1 = ['a', 'b', 'c']
var arr2 = arr1.splice(1, 2, 'd', 'e') // 从索引1开始，删除两个元素，添加'd', 'e'
console.log(arr1)  
>['a', 'd', 'e']
console.log(arr2)
>['b', 'c']

参数：
参数1：要开始更改数组的索引。
参数2：要从开始索引处（参数1）删除元素的个数。0表示不删除 只添加（需要有参数3）。默认为到元素末尾。
参数3：从开始索引处（参数1）要添加的元素。没有 则只删除不添加。
返回值：已删除的元素组成的数组。（改变原数组）

23、Array.toString()：数组直接转化为字符串。

var arr1 = [1, 2, 'a']
var string1 = arr1.toString()
console.log(arr1)
>'1, 2, a'

返回值：数组元素转化而来的字符串。