Array.from()
Array.prototype.from() 方法从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。
语法
Array.from(arrayLike[, mapFn[, thisArg]])
参数
-
arrayLike：想要转换成数组的伪数组对象或可迭代对象。 -
mapFn可选：如果指定了该参数，新数组中的每个元素会执行该回调函数。 -
thisArg可选：可选参数，执行回调函数mapFn时this对象。
返回值
一个新的数组实例，若不能转换，则会返回一个空数组。
使用
// 转换伪数组对象
let obj = {
'0': 'a',
'1': 'b',
'2': 'c',
length: 3
}
console.log(Array.from(obj)) // [ 'a', 'b', 'c' ]
console.log(Array.from('hello')) // [ 'h', 'e', 'l', 'l', 'o' ]
// 转换可迭代对象
const set = new Set()
set.add(1)
set.add(1)
set.add(2)
set.add(3)
console.log(Array.from(set)) // [ 1, 2, 3 ]
const map = new Map()
map.set('0', 'a')
map.set('1', 'b')
map.set('2', 'c')
console.log(Array.from(map)) // [ [ '1', 'a' ], [ '2', 'b' ], [ '3', 'c' ] ]
Array.isArray()
Array.isArray() 用于确定传递的值是否是一个 Array。
语法
Array.isArray(obj)
参数
obj：需要检测的值。
返回值
如果值是 Array，则为 true，否则为 false。
使用
console.log(Array.isArray('张三')) // false
console.log(Array.isArray({ name: '张三' })) // false
console.log(Array.isArray([])) // true
Array.of()
Array.of() 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。
Array.of() 和 Array 构造函数之间的区别在于处理整数参数：Array.of(7) 创建一个具有单个元素 7 的数组，而 Array(7) 创建一个长度为7的空数组（注意：这是指一个有7个空位(empty)的数组，而不是由7个undefined组成的数组）。
语法
Array.of(element0[, element1[, ...[, elementN]]])
参数
element N：任意个参数，将按顺序成为返回数组中的元素。
返回值
新的 Array 实例。
使用
console.log(Array(3)) // [ <3 empty items> ]
console.log(Array.of(1, 2, 3)) // [ 1, 2, 3 ]
console.log(Array.of(1, true, undefined, null, Symbol())) // [ 1, true, undefined, null, Symbol() ]
Array.prototype.concat()
concat() 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。
语法
var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
参数
value N：数组和/或值，将被合并到一个新的数组中。如果省略了所有valueN参数，则concat会返回调用此方法的现存数组的一个浅拷贝。
返回值
新的 Array 实例。
使用
const arr1 = [1, 2, 3]
const arr2 = ['a', 'b', 'c']
const arr3 = [4, 5, 6]
console.log(arr1.concat(arr2)) // [ 1, 2, 3, 'a', 'b', 'c' ]
console.log(arr1.concat(arr2, arr3)) // [ 1, 2, 3, 'a', 'b', 'c', 4, 5, 6 ]
Array.prototype.copyWithin()
copyWithin() 方法浅复制数组的一部分到同一数组中的另一个位置并返回它，不会改变原数组的长度(会改变数组)。
语法
arr.copyWithin(target[, start[, end]])
参数
target：0 为基底的索引，复制序列到该位置。如果是负数，target将从末尾开始计算。如果target大于等于arr.length，将会不发生拷贝。如果target在start之后，复制的序列将被修改以符合arr.length。start可选：0 为基底的索引，开始复制元素的起始位置。如果是负数，start将从末尾开始计算。如果start被忽略，copyWithin将会从0开始复制。end可选：0 为基底的索引，开始复制元素的结束位置。copyWithin将会拷贝到该位置，但不包括end这个位置的元素。如果是负数，end将从末尾开始计算。如果end被忽略，copyWithin方法将会一直复制至数组结尾（默认为arr.length）。
返回值
改变后的数组。
使用
const arr1 = [1, 2, 3, 4, 5]
console.log(arr1.copyWithin(-2)) // [ 1, 2, 3, 1, 2 ]
// Array.prototype.copyWithin() 方法会改变原数组
console.log(arr1) // [ 1, 2, 3, 1, 2 ]
const arr2 = [1, 2, 3, 4, 5]
console.log(arr2.copyWithin(0, 2)) // [ 3, 4, 5, 4, 5 ]
const arr3 = [1, 2, 3, 4, 5]
console.log(arr3.copyWithin(0, 1, 2)) // [ 2, 2, 3, 4, 5 ]
const arr4 = [1, 2, 3, 4, 5]
console.log(arr4.copyWithin(-3)) // [ 1, 2, 1, 2, 3 ]
const arr5 = [1, 2, 3, 4, 5]
console.log(arr5.copyWithin(-2, -4, -1)) // [ 1, 2, 3, 2, 3 ]
Array.prototype.entries()
entries() 方法返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对。
语法
arr.entries()
返回值
一个新的 Array 迭代器对象。
使用
const arr = ['a', 'b', 'c']
for (let item of arr.entries()) {
console.log(item)
}
// [ 0, 'a' ]
// [ 1, 'b' ]
// [ 2, 'c' ]
Array.prototype.keys()
keys() 方法返回一个包含数组中每个索引键的Array Iterator对象。
语法
arr.keys()
返回值
一个新的 Array 迭代器对象。
使用
const arr = ['a', 'b', 'c']
console.log(arr.keys()) // Object [Array Iterator] {}
console.log(Array.from(arr.keys())) // [ 0, 1, 2 ]
Array.prototype.values()
values() 方法返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值
语法
arr.values()
返回值
一个新的 Array 迭代对象。
使用
const arr = ['a', 'b', 'c']
console.log(arr.values()) // Object [Array Iterator] {}
console.log(Array.from(arr.values())) // [ 'a', 'b', 'c' ]
Array.prototype.fill()
fill() 方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引，会修改原数组。
语法
arr.fill(value[, start[, end]])
参数
value：用来填充数组元素的值。start可选：起始索引，默认值为0。end可选：终止索引，默认值为this.length。
返回值
修改后的数组。
使用
const arr1 = [1, 2, 3, 4, 5]
console.log(arr1.fill(6)) // [ 6, 6, 6, 6, 6 ]
// Array.prototype.fill() 会修改原数组
console.log(arr1) // [ 6, 6, 6, 6, 6 ]
const arr2 = [1, 2, 3, 4, 5]
console.log(arr2.fill(6, 3)) // [ 1, 2, 3, 6, 6 ]
const arr3 = [1, 2, 3, 4, 5]
console.log(arr3.fill(6, 3, 4)) // [ 1, 2, 3, 6, 5 ]
Array.prototype.every()
every() 方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。
注意：若空数组调用此方法，在一切情况下都会返回
true。
语法
arr.every(callback(element[, index[, array]])[, thisArg])
参数
callback：用来测试每个元素的函数，它可以接收三个参数：element：用于测试的当前值。index可选：用于测试的当前值的索引。array可选：调用every的当前数组。
thisArg可选：执行callback时使用的this值。
返回值
如果回调函数的每一次返回都为 true 值，返回 true ，否则返回 false。
使用
// 判断数组中的元素是否都是偶数
const arr = [1, 2, 3, 4, 5]
const res = arr.every(val => val % 2 === 0)
console.log(res) // false
Array.prototype.some()
some() 方法测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值。
注意：如果用一个空数组进行测试，在任何情况下它返回的都是
false。
语法
arr.some(callback(element[, index[, array]])[, thisArg])
参数
callback：用来测试每个元素的函数，它可以接收三个参数：element：用于测试的当前值。index可选：用于测试的当前值的索引。array可选：调用some的当前数组。
thisArg可选：执行callback时使用的this值。
返回值
数组中有至少一个元素通过回调函数的测试就会返回true；所有元素都没有通过回调函数的测试返回值才会为false。
使用
const nums = [1, 2, 3, 4, 5]
// 判断数组中是否有元素是偶数
console.log(nums.some(num => num % 2 === 0)) // true
Array.prototype.map()
map() 方法创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值，不会改变原数组。
语法
var new_array = arr.map(function callback(currentValue[, index[, array]]) {
// Return element for new_array
}[, thisArg])
参数
callback：生成新数组元素的函数，它可以接收三个参数：currentValue：callback数组中正在处理的当前元素。index可选：callback数组中正在处理的当前元素的索引。array可选：map方法调用的数组。
thisArg可选：执行callback时使用的this值。
返回值
一个由原数组每个元素执行回调函数的结果组成的新数组。
使用
const arr = [1, 2, 3, 4, 5]
// 获取该数组每个元素的平方组成的新数组
const newArr = arr.map(cur => cur ** 2)
console.log(newArr) // [ 1, 4, 9, 16, 25 ]
// 原数组不变
console.log(arr) // [ 1, 2, 3, 4, 5 ]
Array.prototype.filter()
filter() 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素，不会修改原数组。
语法
var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
参数
callback：用来测试数组的每个元素的函数。返回true表示该元素通过测试，保留该元素，false则不保留。它接受以下三个参数：element：数组中当前正在处理的元素。index可选：正在处理的元素在数组中的索引。array可选：调用了filter的数组本身。
thisArg可选：执行callback时，用于this的值。
返回值
一个新的、由通过测试的元素组成的数组，如果没有任何数组元素通过测试，则返回空数组。
使用
const arr = [1, 2, 3, 4, 5]
// 获取原数组所有奇数元素
const oddArr = arr.filter(val => val % 2 === 1)
console.log(oddArr) // [ 1, 3, 5 ]
// Array.prototype.filter() 不会修改原数组
console.log(arr) // [ 1, 2, 3, 4, 5 ]
Array.prototype.reduce()
reduce() 方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值，不会改变原数组。
语法
arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])
参数
callback：执行数组中每个值 (如果没有提供initialValue则第一个值除外)的函数，包含四个参数：accumulator：累计器累计回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue（见于下方）。currentValue：数组中正在处理的元素。index可选：数组中正在处理的当前元素的索引。 如果提供了initialValue，则起始索引号为0，否则从索引1起始。array可选：调用reduce()的数组。
initialValue可选：作为第一次调用callback函数时的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。
返回值
函数累计处理的结果
使用
const nums = [10, 2, 3, 4, 5]
// 获取数组所有元素平方的和
// 若没有初始值，则默认初始值为第一个元素，遍历从第二个元素开始
const sum1 = nums.reduce((total, curr) => total + curr ** 2)
console.log(sum1) // 64
// 若有初始值，则从第一个元素开始遍历
const sum2 = nums.reduce((total, curr) => total + curr ** 2, 0)
console.log(sum2) // 154
Array.prototype.reduceRight()
功能和 Array.prototype.reduce() 类似，只不过执行遍历方向是从右往左，不会改变原数组。
Array.prototype.find()
find() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。
语法
arr.find(callback[, thisArg])
参数
callback：在数组每一项上执行的函数，接收 3 个参数：element：当前遍历到的元素。index可选：当前遍历到的索引。array可选：调用find的数组。
thisArg可选：执行callback时作为this对象的值。
返回值
数组中第一个满足所提供测试函数的元素的值，否则返回 undefined。
使用
const arr = [1, 2, 3, 4, 5]
// 获取数组中第一个大于等于 4 的元素
const res = arr.find(val => val >= 4)
console.log(res) // 4
Array.prototype.findIndex()
findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回-1。
语法
arr.findIndex(callback[, thisArg])
参数
callback：针对数组中的每个元素, 都会执行该回调函数, 执行时会自动传入下面三个参数:element：当前遍历到的元素。index可选：当前遍历到的索引。array可选：调用findIndex的数组。
thisArg可选：执行callback时作为this对象的值。
返回值
数组中通过提供测试函数的第一个元素的索引。否则，返回-1。
使用
const arr = [1, 2, 3, 4, 5]
// 获取数组中第一个大于等于 4 的元素下标
const res = arr.findIndex(val => val >= 4)
console.log(res) // 3
Array.prototype.flat()
flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回，不会修改原数组。
语法
var newArray = arr.flat([depth])
参数
depth可选：指定要提取嵌套数组的结构深度，默认值为 1。
返回值
一个包含将数组与子数组中所有元素的新数组。
注意：
flat()方法会移除数组中的空项。
使用
const arr1 = [1, 2, [3, 4]]
console.log(arr1.flat()) // [ 1, 2, 3, 4 ]
// Array.prototype.flat() 方法不会修改原数组
console.log(arr1) // [ 1, 2, [ 3, 4 ] ]
const arr2 = [1, 2, [[3, 4]]]
// 提取嵌套数组结构深度默认为 1
console.log(arr2.flat()) // [ 1, 2, [ 3, 4 ] ]
console.log(arr2.flat(2)) // [ 1, 2, 3, 4 ]
Array.prototype.forEach()
forEach() 方法对数组的每个元素执行一次给定的函数。
语法
arr.forEach(callback(element[, index [, array]])[, thisArg])
参数
callback：针对数组中的每个元素, 都会执行该回调函数, 执行时会自动传入下面三个参数:element：当前遍历到的元素。index可选：当前遍历到的索引。array可选：调用findIndex的数组。
thisArg可选：执行callback时作为this对象的值。
返回值
undefined。
使用
const arr = [1, 2, 3, 4, 5]
// 打印数组所有元素
arr.forEach(val => console.log(val))
// 1
// 2
// 3
// 4
// 5
Array.prototype.includes()
includes() 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。
注意：使用
includes()比较字符串和字符时是区分大小写。
语法
arr.includes(valueToFind[, fromIndex])
参数
valueToFind：需要查找的元素值。fromIndex可选：从fromIndex索引处开始查找valueToFind。如果为负值，则按升序从array.length + fromIndex的索引开始搜 （即使从末尾开始往前跳fromIndex的绝对值个索引，然后往后搜寻）。默认为 0。
返回值
返回一个布尔值 Boolean，如果在数组中找到了（如果传入了 fromIndex ，表示在 fromIndex 指定的索引范围中找到了）则返回 true 。
使用
const arr = [1, 2, 3, 4, 5]
console.log(arr.includes(2)) // true
// 从第三个元素开始查找
console.log(arr.includes(2, 2)) // false
Array.prototype.indexOf()
indexOf()方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
语法
arr.indexOf(searchElement[, fromIndex])
参数
searchElement：要查找的元素；fromIndex可选：开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找 ，以此类推。 注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。如果抵消后的索引值仍小于0，则整个数组都将会被查询。其默认值为0。
返回值
首个被找到的元素在数组中的索引位置；若没有找到则返回 -1。
使用
const arr = [1, 2, 3, 4, 5]
console.log(arr.indexOf(2)) // 1
// 从第三个元素开始查找
console.log(arr.indexOf(2, 2)) // -1
Array.prototype.lastIndexOf()
lastIndexOf() 方法返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。
语法
arr.lastIndexOf(searchElement[, fromIndex])
参数
searchElement：要查找的元素；fromIndex可选：从此位置开始逆向查找。默认为数组的长度减 1(arr.length - 1)，即整个数组都被查找。如果该值大于或等于数组的长度，则整个数组会被查找。如果为负值，将其视为从数组末尾向前的偏移。即使该值为负，数组仍然会被从后向前查找。如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。
返回值
数组中该元素最后一次出现的索引，如未找到返回-1。
使用
const arr = [1, 2, 3, 4, 5]
console.log(arr.lastIndexOf(4)) // 3
// 从第 3 个元素开始往前查找
console.log(arr.lastIndexOf(4, 2)) // -1
Array.prototype.join()
join() 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个元素，那么将返回该元素而不使用分隔符。
语法
arr.join([separator])
参数
separator可选：指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。如果缺省该值，数组元素用逗号（,）分隔。如果separator是空字符串("")，则所有元素之间都没有任何字符。
返回值
一个所有数组元素连接的字符串。如果 arr.length 为0，则返回空字符串。
使用
const arr = ['张三', '李四', '王五']
// 默认用 ‘,’ 分隔
console.log(arr.join()) // 张三,李四,王五
console.log(arr.join('')) // 张三李四王五
console.log(arr.join(' & ')) // 张三 & 李四 & 王五
Array.prototype.push()
push() 方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。该方法会改变原有数组。
语法
arr.push(element1, ..., elementN)
参数
elementN：被添加到数组末尾的元素。
返回值
当调用该方法时，新的 length 属性值将被返回。
使用
const names = ['张三', '李四']
// 添加 ‘王五’，并返回数组的新长度
console.log(names.push('王五')) // 3
console.log(names) // [ '张三', '李四', '王五' ]
Array.prototype.pop()
pop()方法从数组中删除最后一个元素，并返回该元素的值。该方法会改变原有数组。
语法
arr.pop()
返回值
从数组中删除的元素(当数组为空时返回undefined)。
使用
const arr = [1, 2, 3, 4, 5]
console.log(arr.pop()) // 5
console.log(arr.pop()) // 4
console.log(arr.pop()) // 3
Array.prototype.shift()
shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。
语法
arr.shift()
返回值
从数组中删除的元素; 如果数组为空则返回undefined 。
使用
const nums = [1, 2, 3, 4, 5]
console.log(nums.shift()) // 1
console.log(nums) // [ 2, 3, 4, 5 ]
Array.prototype.unshift()
unshift() 方法将一个或多个元素添加到数组的开头，并返回该数组的新长度。该方法会改变原有数组。
语法
arr.unshift(element1, ..., elementN)
参数
elementN：要添加到数组开头的一个或多个元素。
返回值
当调用该方法时，新的 length 属性值将被返回。
使用
const nums = [1, 2, 3]
// 在数组开头添加一个元素
console.log(nums.unshift(0)) // 4
console.log(nums) // [ 0, 1, 2, 3 ]
// 在数组开头添加多个元素
console.log(nums.unshift(-2, -1)) // 6
console.log(nums) // [ -2, -1, 0, 1, 2, 3 ]
Array.prototype.splice()
splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。
语法
array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
参数
start：指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从-1计数，这意味着-n是倒数第n个元素并且等价于array.length-n）；如果负数的绝对值大于数组的长度，则表示开始位置为第0位。deleteCount可选：整数，表示要移除的数组元素的个数。如果deleteCount大于start之后的元素的总数，则从start后面的元素都将被删除（含第start位）。如果deleteCount被省略了，或者它的值大于等于array.length - start(也就是说，如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。如果deleteCount是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。item1, item2, ...可选：要添加进数组的元素,从start位置开始。如果不指定，则splice()将只删除数组元素。
返回值
由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。
使用
let fruits = ['apple', 'banana', 'grape']
// 只有一个参数，删除后续所有元素
// Array.prototype.splice() 方法返回被删除元素组成的数组
// 该方法会改变原数组
console.log(fruits.splice(1)) // [ 'banana', 'grape' ]
console.log(fruits) // [ 'apple' ]
// 重置数据
fruits = ['apple', 'banana', 'grape']
// 两个参数，删除指定数目数据
console.log(fruits.splice(1, 1)) // [ 'banana' ]
console.log(fruits) // [ 'apple', 'grape' ]
// 重置数据
fruits = ['apple', 'banana', 'grape']
// 三个参数，添加元素
console.log(fruits.splice(1, 0, 'pineapple')) // []
console.log(fruits) // [ 'apple', 'pineapple', 'banana', 'grape' ]
// 重置数据
fruits = ['apple', 'banana', 'grape']
// 三个参数，删除元素并添加元素
console.log(fruits.splice(1, 1, 'pineapple', 'orange')) // [ 'banana' ]
console.log(fruits) // [ 'apple', 'pineapple', 'orange', 'grape' ]
Array.prototype.reverse()
reverse() 方法将数组中元素的位置颠倒，并返回该数组。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。该方法会改变原数组。
语法
arr.reverse()
返回值
颠倒后的数组。
使用
const nums = [1, 2, 3, 4, 5]
console.log(nums.reverse()) // [ 5, 4, 3, 2, 1 ]
// Array.prototype.reverse() 方法会改变原数组
console.log(nums) // [ 5, 4, 3, 2, 1 ]
Array.prototype.sort()
sort() 方法用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的。由于它取决于具体实现，因此无法保证排序的时间和空间复杂性，会改变原数组。
语法
arr.sort([compareFunction])
参数
compareFunction：用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。firstEl：第一个用于比较的元素。secondEl：第二个用于比较的元素。
返回值
排序后的数组。请注意，数组已原地排序，并且不进行复制。
使用
// 对字符串进行排序，很 ok
const animals = ['dog', 'cat', 'pig', 'monkey']
console.log(animals.sort()) // [ 'cat', 'dog', 'monkey', 'pig' ]
// Array.prototype.sort() 方法会改变原数组
console.log(animals) // [ 'cat', 'dog', 'monkey', 'pig' ]
// 直接对数字进行排序，有问题
const nums1 = [3, 10, 1, 4, 5]
console.log(nums1.sort()) // [ 1, 10, 3, 4, 5 ]
// 对于数字排序，需要传入比较函数进行排序
const nums2 = [3, 10, 1, 4, 5]
// 若比较函数返回 firstNum - secondNum，则按照升序排序
// 反之，比较函数返回 secondNum - firstNum，则按照降序排序
console.log(nums2.sort((firstNum, secondNum) => firstNum - secondNum)) // [ 1, 3, 4, 5, 10 ]
console.log(nums2.sort((firstNum, secondNum) => secondNum - firstNum)) // [ 10, 5, 4, 3, 1 ]
Array.prototype.slice()
slice() 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。
语法
arr.slice([begin[, end]])
参数
begin可选：提取起始处的索引（从0开始），从该索引开始提取原数组元素。如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2)表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。如果省略begin，则slice从索引0开始。如果begin超出原数组的索引范围，则会返回空数组。end可选：提取终止处的索引（从0开始），在该索引处结束提取原数组元素。slice会提取原数组中索引从begin到end的所有元素（包含begin，但不包含end）。如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。slice(-2,-1)表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。如果end被省略，则slice会一直提取到原数组末尾。如果end大于数组的长度，slice也会一直提取到原数组末尾。
返回值
一个含有被提取元素的新数组。
使用
// Array.prototype.slice() 方法用于提取数组中的某些元素，不会改变原数组
// slice 单词的含义中包含 "切片"，比较好记忆
const animals = ['cat', 'dog', 'pig', 'monkey']
console.log(animals.slice(2)) // [ 'pig', 'monkey' ]
console.log(animals.slice(2, 3)) // [ 'pig' ]
// 不会改变原数组
console.log(animals) // [ 'cat', 'dog', 'pig', 'monkey' ]
Array.prototype.toString()
toString() 返回一个字符串，表示指定的数组及其元素。
注意：
语法
arr.toString()
返回值
一个表示指定的数组及其元素的字符串。
使用
const nums = [1, 2, 3, 4, 5]
console.log(nums.toString()) // 1,2,3,4,5
[Array.prototype@@iterator](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/@@iterator)
@@iterator 属性和 Array.prototype.values() 属性的初始值是同一个函数对象。
语法
arr[Symbol.iterator]()
返回值
数组的 iterator 方法，默认情况下，与 values() 返回值相同， arr[Symbol.iterator] 则会返回 values() 函数。
使用
const arr = ['a', 'b', 'c']
const arrValues = arr[Symbol.iterator]()
// 循环遍历输出
for (let val of arrValues) {
console.log(val)
}
// a
// b
// c