[JavaScript知识库]js 数组方法汇总(全面）

Array.from(arrayLike[, mapFn[, thisArg]])方法对一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。
参数
arrayLike
想要转换成数组的伪数组对象或可迭代对象。
mapFn 可选
如果指定了该参数，新数组中的每个元素会执行该回调函数。
thisArg 可选
可选参数，执行回调函数 mapFn 时 this 对象。
返回值
一个新的数组实例。

 var testArr= Array.from([1,2,3],x=>x*10)
        console.log(testArr)
        打印结果：[10, 20, 30]

//Array.isArray(obj) 用于确定传递的值是否是一个 Array。
//参数
// obj
// 需要检测的值。
// 返回值
// 如果值是 Array，则为true; 否则为false。

console.log(Array.isArray([1,2,3]))
打印结果：true

Array.of(element0[, element1[, …[, elementN]]]) 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。
参数
elementN
任意个参数，将按顺序成为返回数组中的元素。
返回值
新的 Array 实例。

 console.log(Array.of(1,2))
        //打印结果：[1, 2]                      

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

   const array1 = ['a', 'b'];
 const array2 = ['c', 'd'];
   const array3 = array1.concat(array2);
   console.log(array3)打印结果：['a', 'b','c', 'd']

copyWithin(target[, start[, end]]) 方法浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。
target 必需。复制到指定目标索引位置。
start 可选。元素复制的起始位置。
end 可选。停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数。

 var copyWithinArr=['a','b','c','d','e','f']
console.log(copyWithinArr.copyWithin(0,1,3))
打印结果：["b", "c", "c", "d", "e", "f"]

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

var entriesArr=['a','b','c','d']
console.log(entriesArr.entries())
打印结果：Array Iterator {}
__proto__: Array Iterator
next: ? next()
Symbol(Symbol.toStringTag): "Array Iterator"
__proto__: Object

array.every(function(currentValue,index,arr), thisValue) 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）。
如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
如果所有元素都满足条件，则返回 true。

var everyArr=[11,22,33,44,55]
var result=everyArr.every(function(currentValue,index,everyArr){
		      return currentValue>40
		    })
console.log(result)
打印结果：false

fill(value, start, end)方法用于将一个固定值替换数组的元素。
value 必需。填充的值。
start 可选。开始填充位置。
end 可选。停止填充位置 (默认为 array.length)

var fillArr=['a','b','c','d','e']
console.log(fillArr.fill("f",2,5))
打印结果：["a", "b", "f", "f", "f"]

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

console.log([1,2,3,4,5].filter(val=>val>2))
打印结果：[3, 4, 5]

find() 方法返回通过测试（函数内判断）的数组的第一个元素的值。
当数组中的元素在测试条件时返回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。
如果没有符合条件的元素返回 undefined

var findArr=[1,2,3,4,5,6]
var result =findArr.find(value=>value>3)
console.log(result) 
打印结果：4

findIndex() 方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置。
当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引位置，之后的值不会再调用执行函数。
如果没有符合条件的元素返回 -1

var findArr=[1,2,3,4,5,6]
var result =findArr.findIndex(value=>value>3)
console.log(result)
打印结果：3

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

let arr = [1,2,[3,[4,[5]]]]
const reasut2 = arr.flat(3)
console.log(reasut2)
打印结果： [1, 2, 3, 4, 5]

flatMap(function callback(currentValue[, index[, array]]){
//return element for new_array}[, thisArg])
方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组.
返回值：一个新的数组，其中每个元素都是回调函数的结果，并且结构深度 depth 值为1。

const stringArr=["Today is a good day","how are you"]
const result=stringArr.flatMap((value)=>value.split(' '))
console.log(result)
打印结果：["Today", "is", "a", "good", "day", "how", "are", "you"]

forEach(function(currentValue, index, arr), thisValue)方法按顺序为数组中的每个元素调用一次函数。
返回值： undefined

 var arr =[1,2,3,4,5]
arr.forEach((val,index ,arr)=>{
     arr[index]= val*10
})
console.log(arr)
打印结果：[10, 20, 30, 40, 50]

includes(valueToFind[, fromIndex])方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回 false。

 console.log([1, 2, 3].includes(2))
 打印结果：true

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

      console.log(['a','b','c'].indexOf('a'))
      打印结果：0

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

console.log(['a','b','c'].join('-'))
打印结果：a-b-c

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

console.log(['a','b','c'].keys())
打印结果：Array Iterator {}
__proto__: Array Iterator
next: ? next()
Symbol(Symbol.toStringTag): "Array Iterator"
__proto__: Object

lastIndexOf(searchElement[, fromIndex]) 方法返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。

console.log(['a','b','c','a'].lastIndexOf('a'))
打印结果：3

array.map(function(currentValue,index,arr), thisValue)方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
方法按照原始数组元素顺序依次处理元素。

 const arr=[1,2,3,4,5]
const newArr=arr.map(val=>val*10)
console.log(newArr)
打印结果： [10, 20, 30, 40, 50]

pop() 方法用于删除数组的最后一个元素并返回删除的元素

 console.log([1,2,3,4,5].pop())
 打印结果：5

push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。

 console.log([1,2,3,4,5].push(7,8,9))
 打印结果：8

reduce(function(total, currentValue, currentIndex, arr), initialValue)方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。

let result= [1,2,3,4,5].reduce((total,currentValue)=>{return total+currentValue},0)
console.log(result)
打印结果：15

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

const array1 = [[0, 1], [2, 3], [4, 5]].reduceRight(
  (accumulator, currentValue) => accumulator.concat(currentValue)
);
console.log(array1);
打印结果 [4, 5, 2, 3, 0, 1]

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

console.log([1,2,3,4,5].reverse())
打印结果 [5, 4, 3, 2, 1]

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

console.log([1,2,3,4,5].shift())
打印结果  1

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

console.log([1,2,3,4,5].slice(1,3))
打印结果：[2, 3]

some(callback(element[, index[, array]])[, thisArg]) 方法测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值。

console.log([1,2,3,4,5].some(value=>value>2))
打印结果：true

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

 console.log([10,2,93,43,15].sort((pre,after)=>pre-after))
 打印结果：[2, 10, 15, 43, 93]

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

 let arr=['a','b','c','d']
 console.log(arr.splice(1,1,'e','f'))
 console.log(arr)
 打印结果：["b"]
		["a", "e", "f", "c", "d"]

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

console.log(['a','b','c','d'].toString())
打印结果：a,b,c,d

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

console.log(['a','b','c','d'].unshift("j","k"))
打印结果：6

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

console.log(['a','b','c','d'].values())
打印结果：
Array Iterator {}
__proto__: Array Iterator
next: ? next()
Symbol(Symbol.toStringTag): "Array Iterator"
__proto__: Object