js数组常用方法

findIndex

返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回-1。

// 返回值：数组下标
// 是否改变原数组：否
var arr = [3,4,5,3,2,4,89,100,23]
var index = arr.findIndex(item => item == 100)
console.log(arr)    // [3, 4, 5, 3, 2, 4, 89, 100, 23]
console.log(index)  // 7

find

返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined

// 返回值：数组的某项
// 是否改变原数组：否
var arr = [4,5,2,7,5]
var item = arr.find(item => item>4)
console.log(arr)    // [4, 5, 2, 7, 5]
console.log(item)   // 5

indexOf 

返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1

// 返回值：数组下标
// 是否改变原数组：否
var arr = ['a','b','c']
var index = arr.indexOf('b')
console.log(arr)    // ['a','b','c']
console.log(index)  // 1

lastIndexOf

返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1

// 返回值：数组下标
// 是否改变原数组：否
var arr = [4,5,2,7,5]
var item = arr.lastIndexOf(5)
console.log(arr)    // [4, 5, 2, 7, 5]
console.log(item)   // 4

slice

返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变

// 返回值：新数组
// 是否改变原数组：否
var arr = [4,5,2,7,5]
var item = arr.slice(2,4)
console.log(arr)    // [4, 5, 2, 7, 5]
console.log(item)   // [2, 7]

keys

返回一个包含数组中每个索引键的Array Iterator对象。

// 返回值：Iterator对象
// 是否改变原数组：否
var arr = ['a','b','c']
var iterator = arr.keys()
for (const key of iterator) {
    console.log(key)    // 0,1,2
}
console.log(arr)    // ['a','b','c']

values

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

// 返回值：Iterator对象
// 是否改变原数组：否
var arr = ['a','b','c']
var iterator = arr.values()
for (const value of iterator) {
    console.log(value)    // a,b,c
}
console.log(arr)    // ['a','b','c']

forEach

对数组的每个元素执行一次给定的函数

// 返回值：undefined
// 是否改变原数组：否
var arr = ['a','b','c']
let res = arr.forEach(item=>{
    console.log(item)   // a,b,c
})
console.log(arr)    // ['a','b','c']
console.log(res)    // undefined

includes

用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回 false。

// 返回值：Boolean类型
// 是否改变原数组：否
var arr = ['a','b','c']
var index = arr.includes('b')
console.log(arr)    // ['a','b','c']
console.log(index)  // true

join

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

// 返回值：String类型
// 是否改变原数组：否
var arr = ['a','b','c']
var res = arr.join(',')
console.log(arr)    // ['a','b','c']
console.log(res)  // a,b,c

flat

会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。

// 返回值：新数组
// 是否改变原数组：否
var arr = ['a','b','c',['d']]
var res = arr.flat('2')
console.log(arr)    // ['a','b','c',['d']]
console.log(res)  // ["a", "b", "c", "d"]

flatMap

首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。它与 map 连着深度值为1的 flat 几乎相同，但 flatMap 通常在合并成一种方法的效率稍微高一些

// 返回值：新数组
// 是否改变原数组：否
var arr = [1, 2, 3, 4];
var newArr = arr.flatMap(x => [x * 2]);
console.log(arr)    // [1, 2, 3, 4]
console.log(newArr) // [2, 4, 6, 8]

map

创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。

// 返回值：新数组
// 是否改变原数组：否
var arr = [56,34,23,99,23,66,88];
var newArr = arr.map(item=>item*5)
console.log(arr)    // [56, 34, 23, 99, 23, 66, 88]
console.log(newArr) // [280, 170, 115, 495, 115, 330, 440]

some 

测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值。

// 返回值：Boolean
// 是否改变原数组：否
var arr = [56,34,23,99,23,66,88];
var bool = arr.some(item=>item>80)
console.log(arr)    //  [56, 34, 23, 99, 23, 66, 88]
console.log(bool)   //  true

every 

测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。

// 返回值：Boolean
// 是否改变原数组：否
var arr = [56,34,23,99,23,66,88];
var bool = arr.every(item=>item>80)
console.log(arr)    //  [56, 34, 23, 99, 23, 66, 88]
console.log(bool)   //  false

reduce 

对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。

// 返回值：一般是基本数据类型
// 是否改变原数组：否
var arr = [56,34,23,99,23,66,88];
var sum = arr.reduce((sum,item)=>sum+item)
console.log(arr)    //  [56, 34, 23, 99, 23, 66, 88]
console.log(sum)   //  389

filter

创建一个新数组, 其包含通过所提供函数实现的测试的所有元素

// 返回值：新数组
// 是否改变原数组：否
var arr = [56,34,23,99,23,66,88];
var newArr = arr.filter(item=>item>50)
console.log(arr)    //  [56, 34, 23, 99, 23, 66, 88]
console.log(newArr)   //  [56, 99, 66, 88]

concat 

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

// 返回值：合并后的新数组
// 是否改变原数组：否
var arr1 = [1,2];
var arr2 = [3,4];
var newArr = arr1.concat(arr2)
console.log(arr1)    //  [1, 2]
console.log(arr2)    //  [3, 4]
console.log(newArr)  //  [1, 2, 3, 4]

sort

用原地算法对数组的元素进行排序，并返回数组

// 返回值：新数组
// 是否改变原数组：是
var arr = [56,34,23,99,23,66,88];
var newArr = arr.sort()
console.log(arr)    // [23, 23, 34, 56, 66, 88, 99]
console.log(newArr) // [23, 23, 34, 56, 66, 88, 99]

reverse

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

// 返回值：新数组
// 是否改变原数组：是
var arr = ['a', 'b', 'c', 'd', 'e'];
var newArr = arr.reverse()
console.log(arr)    // ["e", "d", "c", "b", "a"]
console.log(newArr) // ["e", "d", "c", "b", "a"]

copyWithin

浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度

// 返回值：新数组
// 是否改变原数组：是
var arr = ['a', 'b', 'c', 'd', 'e'];
var newArr = arr.copyWithin(0,3,4)
console.log(arr)    //  ["d", "b", "c", "d", "e"]
console.log(newArr) // ["d", "b", "c", "d", "e"]

fill

用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引

// 返回值：新数组
// 是否改变原数组：是
var arr = [1, 2, 3, 4, 5, 6];
var newArr = arr.fill('a',0,3)
console.log(arr)    // ["a", "a", "a", 4, 5, 6]
console.log(newArr) // ["a", "a", "a", 4, 5, 6]

splice

通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。

// 返回值：被删除的数组
// 是否改变原数组：是
var arr = [56,34,23,99,23,66,88];
var newArr = arr.splice(1,3)
console.log(arr)    //  [56, 23, 66, 88]
console.log(newArr)   //  [34, 23, 99]

pop

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

// 返回值：被删除的元素
// 是否改变原数组：是
var arr = [1,2,3,4,5,100];
var el = arr.pop()
console.log(arr)    // [1, 2, 3, 4, 5]
console.log(el) // 100

push

将一个或多个元素添加到数组的末尾，并返回该数组的新长度

// 返回值：数组的长度
// 是否改变原数组：是
var arr = [1,2,3,4,5,100];
var length = arr.push('500')
console.log(arr)    // [1, 2, 3, 4, 5, 100, "500"]
console.log(length) // 7

shift

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

// 返回值：被删除的元素
// 是否改变原数组：是
var arr = [1,2,3,4,5,100];
var item = arr.shift()
console.log(arr)    // [2, 3, 4, 5, 100]
console.log(item) // 1

unshift

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

// 返回值：新数组的长度
// 是否改变原数组：是
var arr = [1,2,3,4,5,100];
var length = arr.unshift(-100,0)
console.log(arr)    // [-100, 0, 1, 2, 3, 4, 5, 100]
console.log(length) // 8