数组常用方法

Array.from(arrayLike[, mapFun[, thisArg]]) 方法从一个类似数组或可迭代对象中创建一个新的，浅拷贝的数组实例。

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

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

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

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

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

arr.push(element1, ..., elementN)方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。

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

arr.unshift(element1, ..., elementN)方法将一个或多个元素添加到数组的开头，并返回该数组的新长度(该方法修改原有数组)。

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

arr.slice([begin[, end]])方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。如果begin 和 end为负数则从末尾开始计算。如果 begin 大于原数组的长度，则会返回空数组。如果 end 被省略，则slice 会一直提取到原数组末尾。如果 end 大于数组的长度，slice 也会一直提取到原数组末尾。

array.splice(start[, deleteCount[, item1[, item2[, ...]]]])方法通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。start​如果超出了数组的长度，则从数组末尾开始添加内容。如果start为负数则从末尾开始计算。如果负数的绝对值大于数组的长度，则表示开始位置为第0位。如果 deleteCount 被省略了，那么start之后数组的所有元素都会被删除。

let arr = [1, 2, 3];
let deleteArr = arr.splice(-2, 2);
arr //[1]
deleteArr   //[2, 3]

arr.forEach(callback[, thisArg]) 方法对数组的每个元素执行一次提供的函数。返回undefined。

arr.sort([compareFunction])方法用原地算法对数组的元素进行排序，并返回数组。如果省略compareFunction，则是将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的。由于它取决于具体实现，因此无法保证排序的时间和空间复杂性。

arr.filter(callback(element[, index[, array]])[, thisArg])方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。

arr.indexOf(searchElement[, fromIndex = 0])方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。如果fromIndex大于或等于数组长度，意味着不会在数组里查找，返回-1。如果为负值则从末尾开始计算。 如果arr.length + fromIndex抵消后的索引值仍小于0，则整个数组都将会被查询。

arr.lastIndexOf(searchElement[, fromIndex = arr.length - 1])方法返回指定元素在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。如果 fromIndex 大于或等于数组的长度，则整个数组会被查找。 如果arr.length + fromIndex抵消后的索引值仍小于0，则方法返回 -1，即数组不会被查找。

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

arr.includes(valueToFind[, fromIndex])方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。fromIndex为负值则从末尾开始计算，然后往后搜寻，默认为 0。

// 数组 length 是 3
// fromIndex 是 -100
// 计算出来的 index 是 3 + (-100) = -97
// 如果计算出的索引小于 0，则整个数组都会被搜索
['a', 'b', 'c'].includes('c', -100)			// true

['a', 'b', 'c'].includes('b', -1)			//false

arr.concat(value1[, value2[, ...[, valueN]]]) 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。

[1, 2].concat(3, [4, 5])    //[1, 2, 3, 4, 5]

arr.toString()返回一个字符串，表示指定的数组及其元素。Array对象覆盖了Object的 toString 方法。对于数组对象，toString 方法连接数组并返回一个字符串，其中包含用逗号分隔的每个数组元素。

[1, 2, 'a', '1a'].toString()    // "1,2,a,1a"

arr.fill(value[, start[, end]]) 方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。start 可选，默认值为0。end 可选，默认值为 this.length。

[1, 2, 3, 4].fill(0, 2, 4))    // [1, 2, 0, 0]

arr.find(callback[, thisArg])方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。

[5, 12, 8, 130, 44].find(element => element > 10)   // 12

arr.findIndex(callback[, thisArg])方法返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。

[5, 12, 8, 130, 44].findIndex(element => element > 13)  //3

arr.copyWithin(target[, start[, end]]) 方法浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组。不包括 end 这个位置的元素。target、start和end如果是负数则从末尾开始计算。如果 target 大于等于 arr.length，将会不发生拷贝。如果 start 被忽略，copyWithin 将会从0开始复制。如果 end 被忽略，copyWithin 方法将会一直复制至数组结尾（默认为 arr.length）。

var arr = ['a', 'b', 'c', 'd', 'e'];
arr.copyWithin(0, 3, 4)	// ["d", "b", "c", "d", "e"]
arr.copyWithin(1, 3)	// ["d", "d", "e", "d", "e"]
arr.copyWithin(3, 2)	// ["a", "b", "c", "c", "d"]

arr.flat(depth)方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。depth 可选，指定要提取嵌套数组的结构深度，默认值为 1。

[1, 2, [3, 4]].flat()   // [1, 2, 3, 4]
[1, 2, [3, 4, [5, 6]]].flat()   // [1, 2, 3, 4, [5, 6]]
[1, 2, [3, 4, [5, 6]]].flat(2)  // [1, 2, 3, 4, 5, 6]
arr.flat(Infinity); //使用 Infinity 作为深度，展开任意深度的嵌套数组

arr.flatMap(callback(currentValue[, index[, array]])[, thisArg]) 方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。它与 map 和 深度值1的 flat 几乎相同，但 flatMap 通常在合并成一种方法的效率稍微高一些。

[1, 2, 3, 4].map(x => [x * 2])  // [[2], [4], [6], [8]]
[1, 2, 3, 4].flatMap(x => [x * 2])  // [2, 4, 6, 8]
[1, 2, 3, 4].flatMap(x => [[x * 2]])    // [[2], [4], [6], [8]], flatMap 只会将函数返回的数组 “压平” 一层

arr.every(callback(element[, index[, array]])[, thisArg])方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。注意：若收到一个空数组，此方法在一切情况下都会返回 true。

[1, 30, 39, 29, 10, 13].every(element => element < 40)	// true

arr.some(callback(element[, index[, array]])[, thisArg])方法测试是否至少有一个元素可以通过被提供的函数方法。该方法返回一个Boolean类型的值。

arr.map(callback(currentValue[, index[, array]])[, thisArg])方法创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。

[1, 4, 9, 16].map(x => x * 2)   // [2, 8, 18, 32]

arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。accumulator累计器，initialValue作为第一次调用 callback 函数时的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。

[1, 2, 3, 4].reduce((accumulator, currentValue) => accumulator + currentValue)    // 10, 1 + 2 + 3 + 4
[1, 2, 3, 4].reduce((accumulator, currentValue) => accumulator + currentValue, 5)   // 15, 5 + 1 + 2 + 3 + 4

arr.reduceRight(callback(accumulator, currentValue[, index[, array]])[, initialValue])方法接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。

[1, 2, 3, 4].reduceRight((accumulator, currentValue) => accumulator + currentValue)    // 10, 4 + 3 + 2 + 1
[1, 2, 3, 4].reduceRight((accumulator, currentValue) => accumulator + currentValue, 5)   // 15, 5 + 4 + 3 + 2 + 1

arr.keys()方法返回一个包含数组中每个索引键的Array Iterator对象。

let iterator = ['a', 'b', 'c'].keys(); 
for (let key of iterator) {
	console.log(key); // 0 1 2
}

arr.values()方法返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值。

let iterator = ['a', 'b', 'c'].values();

for (let value of iterator) {
    console.log(value); // "a" "b" "c"
}

arr.entries() 方法返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对。

var iter = ['a', 'b', 'c'].entries();
iter.next().value  // [0, "a"]
iter.next().value  // [1, "b"]