数组对象原生方法
copyWithin 、fill 、pop、push、sort、reverse、shift、unshift、splice、concat、includes 、join、slice、toString、indexOf、lastIndexOf、forEach、entries 、every、some、filter、find、findIndex、keys、values、map、reduce、reduceRight
修改器方法
下面的这些方法会改变调用它们的对象自身的值
copyWithin 这是一个实验性的API，请尽量不要在生产环境中使用它
浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度
/**
* arr.copyWithin(target[, start[, end]])
* @param target
* 0 为基底的索引，复制序列到该位置。如果是负数，target 将从末尾开始计算
* 如果 target 大于等于 arr.length，将会不发生拷贝。如果 target 在 start 之后，复制的序列将被修改以符合 arr.length
* @param start
* 0 为基底的索引，开始复制元素的起始位置。如果是负数，start 将从末尾开始计算
* 如果 start 被忽略，copyWithin 将会从0开始复制
* @param end
* 0 为基底的索引，开始复制元素的结束位置。copyWithin 将会拷贝到该位置，但不包括 end 这个位置的元素。如果是负数， end 将从末尾开始计算
* 如果 end 被忽略，copyWithin 方法将会一直复制至数组结尾（默认为 arr.length）
* @returns [](改变后的数组)
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.copyWithin(0, 4, 5)) //[2, 5, 0, 3, 2, 7, 4, 6, 8, 9, 1]
console.log(arr.copyWithin(1, 4)) //[3, 2, 7, 4, 6, 8, 9, 1, 8, 9, 1]
fill 这是一个实验性的API，请尽量不要在生产环境中使用它
用一个固定值填充一个数组中从起始索引到终止索引内的全部元素，不包括终止索引
/**
* arr.fill(value[, start[, end]])
* @param value
* 用来填充数组元素的值
* @param start
* 起始索引，默认值为0
* @param end
* 终止索引，默认值为 this.length
* @returns [](修改后的数组)
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.fill(0, 2, 4)) // [3, 5, 0, 0, 2, 7, 4, 6, 8, 9, 1]
console.log(arr.fill(5, 1)) // [3, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
console.log(arr.fill(6)) // [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6]
pop
从数组中删除最后一个元素，并返回该元素的值，此方法更改数组的长度
/**
* arr.pop()
* @returns 从数组中删除的元素(当数组为空时返回undefined)
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.pop()) // 1
console.log(arr) // [3, 5, 0, 3, 2, 7, 4, 6, 8, 9]
push
将一个或多个元素添加到数组的末尾，并返回该数组的新长度
/**
* arr.push(element1, ..., elementN)
* @param elementN
* 被添加到数组末尾的元素
* @returns 当调用该方法时，新的 length 属性值将被返回
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.push(7)) // 12
console.log(arr) // [3, 5, 0, 3, 2, 7, 4, 6, 8, 9, 1, 7]
console.log(arr.push(5, 8, 3)) // 15
console.log(arr) // [3, 5, 0, 3, 2, 7, 4, 6, 8, 9, 1, 7, 5, 8, 3]
sort
用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的。由于它取决于具体实现，因此无法保证排序的时间和空间复杂性
/**
* arr.sort([compareFunction])
* @param compareFunction (可选)
* 用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序
* firstEl 第一个用于比较的元素
* secondEl 第二个用于比较的元素
* @returns 排序后的数组。请注意，数组已原地排序，并且不进行复制
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.sort()) // [0, 1, 2, 3, 3, 4, 5, 6, 7, 8, 9]
reverse
将数组中元素的位置颠倒，并返回该数组，该方法会改变原数组
/**
* arr.reverse()
* @returns 颠倒后的数组
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.reverse()) // [1, 9, 8, 6, 4, 7, 2, 3, 0, 5, 3]
shift
从数组中删除第一个元素，并返回该元素的值，此方法更改数组的长度
/**
* arr.shift()
* @returns 从数组中删除的元素; 如果数组为空则返回undefined
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.shift()) // 3
console.log(arr) // [5, 0, 3, 2, 7, 4, 6, 8, 9, 1]
unshift
将一个或多个元素添加到数组的开头，并返回该数组的新长度，该方法修改原有数组
/**
* arr.unshift(element1, ..., elementN)
* @param elementN
* 要添加到数组开头的元素或多个元素
* @returns 当一个对象调用该方法时，返回其 length 属性值
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.unshift(4, 5)) // 13
console.log(arr) // [4, 5, 3, 5, 0, 3, 2, 7, 4, 6, 8, 9, 1]
splice
删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容，此方法会改变原数组
/**
* array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
* @param 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() 将只删除数组元素
* @returns 由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.splice(1, 0, 8)) // []
console.log(arr) // [3, 8, 5, 0, 3, 2, 7, 4, 6, 8, 9, 1]
console.log(arr.splice(4, 2, 7, 2)) // [3, 2]
console.log(arr) // [3, 8, 5, 0, 7, 2, 7, 4, 6, 8, 9, 1]
访问方法
下面的这些方法绝对不会改变调用它们的对象的值，只会返回一个新的数组或者返回一个其它的期望值
concat
用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组
/**
* var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
* @param valueN (可选)
* 数组和/或值，将被合并到一个新的数组中。如果省略了所有 valueN 参数，则 concat 会返回调用此方法的现存数组的一个浅拷贝
* @returns 新的 Array 实例
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
const tempArr = [7, 3, 8, 5]
const tempNewArr = arr.concat(tempArr)
const newArray = arr.concat([7, 3, 8, 5])
console.log(tempNewArr) // [3, 5, 0, 3, 2, 7, 4, 6, 8, 9, 1, 7, 3, 8, 5]
console.log(newArray) // [3, 5, 0, 3, 2, 7, 4, 6, 8, 9, 1, 7, 3, 8, 5]
includes 这是一个实验性的API，请尽量不要在生产环境中使用它
判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false
/**
* arr.includes(valueToFind[, fromIndex])
* @param valueToFind
* 需要查找的元素值
* @param fromIndex （可选）
* 从fromIndex 索引处开始查找 valueToFind。
* 如果为负值，则按升序从 array.length + fromIndex 的索引开始搜
* （即使从末尾开始往前跳 fromIndex 的绝对值个索引，然后往后搜寻），默认为 0
* @returns 返回一个布尔值 Boolean ，如果在数组中找到了（如果传入了 fromIndex ，表示在 fromIndex 指定的索引范围中找到了）则返回 true
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.includes(2)) // true
console.log(arr.includes(11)) // false
join
将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符
/**
* arr.join([separator])
* @param separator （可选）
* 指定一个字符串来分隔数组的每个元素。
* 如果需要，将分隔符转换为字符串。
* 如果缺省该值，数组元素用逗号（,）分隔。
* 如果separator是空字符串("")，则所有元素之间都没有任何字符
* @returns 返回一个布尔值 Boolean ，如果在数组中找到了（如果传入了 fromIndex ，表示在 fromIndex 指定的索引范围中找到了）则返回 true
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.join()) // 3,5,0,3,2,7,4,6,8,9,1
console.log(arr.join('')) // 35032746891
console.log(arr.join('-')) // 3-5-0-3-2-7-4-6-8-9-1
slice
返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end），原始数组不会被改变
/**
* arr.slice([begin[, end]])
* @param begin （可选）
* 提取起始处的索引（从 0 开始），从该索引开始提取原数组元素。
* 如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。
* 如果省略 begin，则 slice 从索引 0 开始。
* 如果 begin 大于原数组的长度，则会返回空数组
* @param end （可选）
* 提取终止处的索引（从 0 开始），在该索引处结束提取原数组元素。slice 会提取原数组中索引从 begin 到 end 的所有元素（包含 begin，但不包含 end
* slice(1,4) 会提取原数组中从第二个元素开始一直到第四个元素的所有元素 （索引为 1, 2, 3的元素）
* 如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。
* slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）
* 如果 end 被省略，则 slice 会一直提取到原数组末尾
* 如果 end 大于数组的长度，slice 也会一直提取到原数组末尾
* @returns 一个含有被提取元素的新数组
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.slice(2)) // [0, 3, 2, 7, 4, 6, 8, 9, 1]
console.log(arr.slice(2, 4)) // [0, 3]
console.log(arr.slice(1, 15)) // [5, 0, 3, 2, 7, 4, 6, 8, 9, 1]
toString
返回一个字符串，表示指定的数组及其元素
/**
* arr.toString()
* @returns 一个表示指定的数组及其元素的字符串
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.toString()) // 3,5,0,3,2,7,4,6,8,9,1
indexOf
返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1
/**
* arr.indexOf(searchElement[, fromIndex])
* @param searchElement
* 要查找的元素
* @param fromIndex （可选）
* 开始查找的位置。
* 如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。
* 如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找 ，以此类推。
* 注意：
* 如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。
* 如果抵消后的索引值仍小于0，则整个数组都将会被查询。其默认值为0
* @returns 首个被找到的元素在数组中的索引位置; 若没有找到则返回 -1
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.indexOf(2)) // 4
console.log(arr.indexOf(10)) // -1
lastIndexOf
返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始
/**
* arr.lastIndexOf(searchElement[, fromIndex])
* @param searchElement
* 要查找的元素
* @param fromIndex （可选）
* 从此位置开始逆向查找。默认为数组的长度减 1(arr.length - 1)，即整个数组都被查找。
* 如果该值大于或等于数组的长度，则整个数组会被查找。
* 如果为负值，将其视为从数组末尾向前的偏移。
* 即使该值为负，数组仍然会被从后向前查找。
* 如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找
* @returns 数组中该元素最后一次出现的索引，如未找到返回-1
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.lastIndexOf(3)) // 3
console.log(arr.lastIndexOf(10)) // -1
迭代方法
在下面的众多遍历方法中，有很多方法都需要指定一个回调函数作为参数。在每一个数组元素都分别执行完回调函数之前，数组的length属性会被缓存在某个地方，所以，如果你在回调函数中为当前数组添加了新的元素，那么那些新添加的元素是不会被遍历到的。此外，如果在回调函数中对当前数组进行了其它修改，比如改变某个元素的值或者删掉某个元素，那么随后的遍历操作可能会受到未预期的影响。总之，不要尝试在遍历过程中对原数组进行任何修改，虽然规范对这样的操作进行了详细的定义，但为了可读性和可维护性，请不要这样做
forEach
方法对数组的每个元素执行一次给定的函数
/**
* arr.forEach(callback(currentValue [, index [, array]])[, thisArg])
* @param callback
* 为数组中每个元素执行的函数，该函数接收一至三个参数：
* currentValue 数组中正在处理的当前元素
* index(可选） 数组中正在处理的当前元素的索引
* array(可选) forEach() 方法正在操作的数组
* @param thisArg(可选)
* 可选参数。当执行回调函数 callback 时，用作 this 的值
* @returns undefined
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
arr.forEach(element => console.log(element))
// 3
// 5
// 0
// 3
// 2
// 7
// 4
// 6
// 8
// 9
// 1
entries 这是一个实验性的API，请尽量不要在生产环境中使用它
返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对
/**
* arr.entries()
* @returns
* 一个新的 Array 迭代器对象。Array Iterator是对象，
* 它的原型（__proto__:Array Iterator）上有一个next方法，可用用于遍历迭代器取得原数组的[key,value]
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
const iterator1 = arr.entries();
console.log(iterator1.next().value) // [0, 3]
console.log(iterator1.next().value) // [1, 5]
console.log(iterator1.next().value) // [2, 0]
every
测试一个数组内的所有元素是否都能通过某个指定函数的测试，它返回一个布尔值
/**
* arr.every(callback(element[, index[, array]])[, thisArg])
* @param callback
* 用来测试每个元素的函数，它可以接收三个参数：
* element 用于测试的当前值
* index(可选) 用于测试的当前值的索引
* array(可选) 调用 every 的当前数组
* @param thisArg(可选)
* 执行 callback 时使用的 this 值
* @returns 如果回调函数的每一次返回都为 truthy 值，返回 true ，否则返回 false
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.every(value => value < 10)) // true
console.log(arr.every(value => value / 2 === 0)) // false
some
测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值
/**
* arr.some(callback(element[, index[, array]])[, thisArg])
* @param callback
* 用来测试每个元素的函数，接受三个参数：
* element 数组中正在处理的元素
* index (可选) 数组中正在处理的元素的索引值
* array (可选) some()被调用的数组
* @param thisArg(可选)
* 执行 callback 时使用的 this 值
* @returns 数组中有至少一个元素通过回调函数的测试就会返回true；所有元素都没有通过回调函数的测试返回值才会为false
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
console.log(arr.some(value => value > 8)) // true
console.log(arr.some(value => value / 2 === 0)) // true
console.log(arr.some(value => value <-1)) // false
filter
创建一个新数组, 其包含通过所提供函数实现的测试的所有元素
/**
* var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
* @param callback
* 用来测试数组的每个元素的函数。返回 true 表示该元素通过测试，保留该元素，false 则不保留,它接受以下三个参数：
* element 数组中当前正在处理的元素
* index (可选) 正在处理的元素在数组中的索引
* array (可选) 调用了 filter 的数组本身
* @param thisArg(可选)
* 执行 callback 时，用于 this 的值
* @returns 一个新的、由通过测试的元素组成的数组，如果没有任何数组元素通过测试，则返回空数组
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
const result = arr.filter(value => value % 2 === 0)
console.log(result) // [0, 2, 4, 6, 8]
find这是一个实验性的API，请尽量不要在生产环境中使用它
返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined
/**
* arr.find(callback[, thisArg])
* @param callback
* 在数组每一项上执行的函数，接收 3 个参数：
* element 当前遍历到的元素
* index (可选) 当前遍历到的索引
* array (可选) 数组本身
* @param thisArg(可选)
* 执行回调时用作this 的对象
* @returns 数组中第一个满足所提供测试函数的元素的值，否则返回 undefined
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
const result = arr.find(value => value > 5)
console.log(result) // 7
findIndex这是一个实验性的API，请尽量不要在生产环境中使用它
返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回-1
/**
* arr.findIndex(callback[, thisArg])
* @param callback
* 针对数组中的每个元素, 都会执行该回调函数, 执行时会自动传入下面三个参数:
* element 当前元素
* index (可选) 当前元素的索引
* array (可选) 调用findIndex的数组
* @param thisArg(可选)
* 执行callback时作为this对象的值.
* @returns 数组中通过提供测试函数的第一个元素的索引。否则，返回-1
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
const result = arr.findIndex(value => value > 5)
console.log(result) // 5
keys 这是一个实验性的API，请尽量不要在生产环境中使用它
返回一个包含数组中每个索引键的Array Iterator对象
/**
* arr.keys()
* @returns 一个新的 Array 迭代器对象
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
const iterator = arr.keys();
for (const key of iterator) {
console.log(key);
}
// 3
// 5
// 0
// 3
// 2
// 7
// 4
// 6
// 8
// 9
// 1
values 这是一个实验性的API，请尽量不要在生产环境中使用它
返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值
/**
* arr.values()
* @returns 一个新的 Array 迭代对象
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
const iterator = arr.values();
for (const values of iterator) {
console.log(values);
}
// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 10
map
创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值
/**
* var new_array = arr.map(function callback(currentValue[, index[, array]]) {
// Return element for new_array
}[, thisArg])
* @param callback
* 生成新数组元素的函数，使用三个参数：
* currentValue callback 数组中正在处理的当前元素
* index (可选) callback 数组中正在处理的当前元素的索引
* array (可选) map 方法调用的数组
* @param thisArg(可选)
* 执行 callback 函数时值被用作this
* @returns 一个由原数组每个元素执行回调函数的结果组成的新数组
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
const result = arr.map(value => value * 2)
console.log(result) // [6, 10, 0, 6, 4, 14, 8, 12, 16, 18, 2]
reduce
对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值
/**
* arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])
* @param callback
* 执行数组中每个值 (如果没有提供 initialValue则第一个值除外)的函数，包含四个参数：
* accumulator 累计器累计回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue（见于下方）
* currentValue 数组中正在处理的元素
* index (可选) 数组中正在处理的当前元素的索引。 如果提供了initialValue，则起始索引号为0，否则从索引1起始
* array (可选) 调用reduce()的数组
* @param initialValue(可选)
* 作为第一次调用 callback函数时的第一个参数的值。
* 如果没有提供初始值，则将使用数组中的第一个元素。
* 在没有初始值的空数组上调用 reduce 将报错
* @returns 函数累计处理的结果
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
const reducer = (accumulator, currentValue) => accumulator + currentValue;
console.log(arr.reduce(reducer)) // 48
console.log(arr.reduce(reducer, 10)) // 58
reduceRight
接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值
/**
* arr.reduceRight(callback(accumulator, currentValue[, index[, array]])[, initialValue])
* @param callback
* 一个回调函数，用于操作数组中的每个元素，它可接受四个参数：
* accumulator
* 累加器：
* 上一次调用回调函数时，回调函数返回的值。
* 首次调用回调函数时，如果 initialValue 存在，累加器即为 initialValue，
* 否则须为数组中的最后一个元素（详见下方 initialValue 处相关说明）
* currentValue 当前元素：当前被处理的元素
* index (可选) 数组中当前被处理的元素的索引
* array (可选) 调用 reduceRight() 的数组
* @param initialValue(可选)
* 首次调用 callback 函数时，累加器 accumulator 的值。
* 如果未提供该初始值，则将使用数组中的最后一个元素，并跳过该元素。
* 如果不给出初始值，则需保证数组不为空。
* 否则，在空数组上调用 reduce 或 reduceRight 且未提供初始值
* （例如 [].reduce( (acc, cur, idx, arr) => {} ) ）的话，
* 会导致类型错误 TypeError: reduce of empty array with no initial value)
* @returns 执行之后的返回值
**/
const arr = [3, 5, 0, 3, 2, 7, 4 , 6, 8, 9, 1]
const temp = [9, 8]
const result = [arr, temp].reduceRight((accumulator, currentValue) => accumulator.concat(currentValue))
console.log(result) // [9, 8, 3, 5, 0, 3, 2, 7, 4, 6, 8, 9, 1]