JS数组方法集合

以下操作均会改变原数组

// 在数组尾部追加元素
arr.push(item)

// 在数组尾部删除元素
arr.pop()

// 在数组头部插入元素
arr.unshift(item)

// 在数组头部删除元素
arr.shift()

// 数组排序，参数是一个回调函数，回调函数的返回值大于0时，交换元素位置，小于等于0时不动
arr.sort((a, b) => {
	// 从小到大排序
	// return a - b
	
	// 从大到小排序
	// return b - a
})

// 数组翻转
arr.reverse()

// 截取或新增元素，在索引的前面新增元素
arr.splice(起始位置索引，要删除的个数，新增元素1, 新增元素2, 新增元素3, ……)

// 将指定位置的元素复制到数组的其他位置（包括起始位置，不包括结束位置）
arr.copyWithin(目标位置索引, 复制的起始位置索引, 复制的结束位置索引)

// 用给定的值填充给定范围的数组元素（包括起始位置，不包括结束位置）
arr.fill(填充的值, 填充起始位置索引, 填充结束位置索引)

以下操作不会改变原数组

// 数组遍历
arr.forEach((item, index) ={

})

// 数组过滤
var newArr = arr.filter((item, index) => {
	// 返回大于2的元素
	return item > 2
})

// 根据给定的方法返回一个新的数组
var newArr = arr.map((item, index) => {
	// 新数组中的每一项都加1
	return item + 1
})

// flatMap类似于map，但当返回的数组中的元素是一维数组时，flatMap会将元素展开。
// 例如map返回一个数组[['a1', 'a2'], ['b1', 'b2'], ['c1', 'c2']]，则flatMap返回的是['a1', 'a2', 'b1', 'b2', 'c1', 'c2']

// 对数组中每一项运行回调函数，返回最后一次回调函数的执行结果
// previousValue：首次运行时如果initialValue有值，则取initialValue的值，如果没有则取数组第一个元素，后面previousValue的值为上一次该回调函数的返回值
var newVal = arr.reduce((previousValue, item, index) => {
	// 若initialValue为空，则newVal的值为数组每项的乘积
	// 若initialValue为2，则newVal的值为数组每项的乘积的2倍
	return previousValue * item
}, initialValue)

// 同上一方法，只是运算顺序是从右向左
var newVal = arr.reduceRight((previousValue, item, index) => {
	// 若initialValue为空，则newVal的值为数组每项的乘积
	// 若initialValue为2，则newVal的值为数组每项的乘积的2倍
	return previousValue * item
}, initialValue)

// 从已有的数组中返回选定的元素（包括起始位置，不包括结束位置）
var newArr = arr.slice(起始位置索引, 结束位置索引)

// 数组合并
var newArr = arr.concat(arr1, item1, item2, ……)

// 判断是否为数组类型
var flag = Array.isArray(arr)

// 检测数组中是否包含某个值
var flag = arr.includes(要查找的值, 从该索引处开始查找)

// 查找符合条件的元素的索引(第一个)，找不到返回-1
var index = arr.indexOf(要查找的值, 从该索引处开始查找)

// 查找符合条件的元素的索引(最后一个)，找不到返回-1
var index = arr.lastIndexOf(要查找的值, 从该索引处开始查找)

// 查找符合条件的元素（第一个），查找到返回元素的值，没有返回undefined
var val = arr.find((item, index) => {
	return item == 8
})

// 查找符合条件的元素（最后一个），查找到返回元素的值，没有返回undefined
var val = arr.findLast((item, index) => {
	return item == 8
})

// 查找符合条件的元素（第一个），查找到返回元素的索引，没有返回-1
var val = arr.findIndex((item, index) => {
	return item == 8
})

// 查找符合条件的元素（最后一个），查找到返回元素的索引，没有返回-1
var val = arr.findLastIndex((item, index) => {
	return item == 8
})

使用静态方法创建一个可变的数组，可以接收任意类型，任意个数的参数

var arr = Array.of('a', 'b', 'c', ['d', 'e'])
console.log(arr)	// ['a', 'b', 'c', ['d', 'e']]

扁平化数组

var arr = [['a', 'b'], [['c', 'd', 'e']], [[['f']]]]

var newArr1 = arr.flat(2)
console.log(newArr1) // ['a', 'b', 'c', 'd', 'e', ['f']]

newArr2 = arr.flat(Infinity)
console.log(newArr2) // ['a', 'b', 'c', 'd', 'e', 'f']

检测数组中是否有一个元素符合某个条件

var arr = [1, 2, 3, 4, 5, 6]

var flag = arr.some((item, index) => {
	return item > 3
})

console.log(flag)	// true

var flag = arr.some((item, index) => {
	return item > 7
})

console.log(flag)	// false

检测数组中所有的元素是否都符合某个条件

var arr = [1, 2, 3, 4, 5, 6]

var flag = arr.every((item, index) => {
	return item > 3
})

console.log(flag)	// false

var flag = arr.every((item, index) => {
	return item > 0
})

console.log(flag)	// true

将数组转换为字符串

var arr = ['a', 'b', 'c', 'd', 'e', 'f']

var str = arr.toString()

console.log(str)

// a,b,c,d,e,f

将数组转换为字符串，并以指定字符作为间隔

var arr = ['a', 'b', 'c', 'd', 'e', 'f']

var str = arr.join('|')

console.log(str)

// a|b|c|d|e|f

返回一个只包含键名的迭代对象

var arr = ['a', 'b', 'c', 'd', 'e', 'f']

var newArr = arr.keys()

for (const item of newArr) {
	console.log(item)
}

// 0
// 1
// 2
// 3
// 4
// 5

返回一个只包含键值得可迭代对象

var arr = ['a', 'b', 'c', 'd', 'e', 'f']

var newArr = arr.values()

for (const item of newArr) {
	console.log(item)
}

// a
// b
// c
// d
// e
// f