目录
push
push() 往数组尾部添加元素，返回新数组的长度，会改变原数组
const arr = [1, 2, 3]
// 返回的是新数组的长度
console.log(arr.push(4)) // 4
// 数组尾部进行添加，会改变原数组
console.log(arr) // [1, 2, 3, 4]unshift
unshift() 往数组头部添加元素，返回新数组的长度，会改变原数组
const arr = [1, 2, 3]
// 返回的是新数组的长度
console.log(arr.unshift(0)) // 4
// 数组尾部进行添加，会改变原数组
console.log(arr) // [0, 1, 2, 3]pop
pop() 删除数组的尾部元素，返回被删除的元素，会改变原数组，并且没有参数
const arr = [1, 2, 3, 4]
// 返回的是被删除的元素，并且没有参数
console.log(arr.pop()) // 4
// 删除数组尾部元素，会改变原数组
console.log(arr) // [1, 2, 3]shift
shift() 删除数组头部的元素，返回被删除的元素，会改变原数组，并且没有参数
const arr = [1, 2, 3, 4]
// 返回的是被删除的元素
console.log(arr.shift()) // 1
// 删除数组尾部元素，会改变原数组
console.log(arr) // [2, 3, 4]filter
filter() 按条件过滤数组，返回一个过滤后的新数组，不会改变原数组
const arr = [1, 2, 3, 4]
// 返回的是过滤后的新数组，需要一个新的变量来接收
const newArr = arr.filter((item, index) => {
// 内部是一个函数，所以一定要有一个返回值
return item > 2
})
console.log(newArr) // [3, 4]
// 不会改变原数组
console.log(arr) // [1, 2, 3, 4]some
some() 寻找是否有满足条件的一项，如果有，返回true，如果没有，则返回false，不会改变原数组
const arr = [1, 2, 3, 4]
// 返回一个布尔值，看是否有满足条件的
let flag = arr.some(item => {
// 内部是一个函数，所以一定要有一个返回值
return item > 5
})
console.log(flag) // false
// 不会改变原数组
console.log(arr) // [1, 2, 3, 4]forEach
forEach() 对数组进行遍历，没有返回值，常用于查找打印输出值
const arr = [1, 2, 3, 4]
// 遍历数组，没有返回值
let res = arr.forEach(item => item + 3)
console.log(res) // undefinedmap
map() 对数组进行处理，返回一个处理后的新数组，不会改变原数组
const arr = [1, 2, 3, 4]
// 迭代数组，对数组中的每一项都进行处理，返回一个处理后的新数组
let newArr = arr.map(item => item + 3)
console.log(newArr) // [4, 5, 6, 7]
// 不会改变原数组
console.log(arr) // [1, 2, 3, 4]reverse
reverse() 翻转数组，没有参数，会改变原数组
const arr = [1, 2, 3, 4]
// 迭代数组，返回一个处理后的新数组，经常用于处理数据
let newArr = arr.reverse()
console.log(newArr) // [4, 3, 2, 1]
console.log(arr) // [4, 3, 2, 1]sort
sort() 对数组里的元素进行排序，但是只能对个位数排序，会改变原数组
const arr = [100, 2, 33, 4]
// 对数组进行排序，但是只能对个位数
let newArr = arr.sort()
console.log(newArr) // [100, 2, 33, 4]
// 会改变原数组
console.log(arr) // [100, 2, 33, 4]
// 排序完整写法 升序(a - b) 降序(b - a)
arr.sort((a, b) => a - b)
console.log(arr) // [2, 4, 33, 100]indexOf
indexOf() 查找数组中的元素，存在，返回索引，不存在，则返回-1
const arr = [100, 2, 33, 4]
// 查找数组中的元素，如果存在，返回索引，如果不存在，则返回-1
let newArr = arr.indexOf(2)
console.log(newArr) // 1lastIndexOf
lastIndexOf() 查找数组中的元素(排到最后的)，存在返回索引，不存在，则返回-1
const arr = [100, 2, 33, 4, 100]
// 查找数组中的元素(排到最后的)，如果存在，返回索引，如果不存在，则返回-1
let newArr = arr.lastIndexOf(100)
console.log(newArr) // 4toString
toString() 数组转换为字符串，返回转换后的字符串(默认逗号分割)，不会改变原数组
const arr = [100, 2, 33, 4, 100]
// 把数组转换为字符串，返回转换后的字符串，不会改变原数组
let str = arr.toString()
console.log(str) // 100,2,33,4,100
// 不会改变原数组
console.log(arr) // [100, 2, 33, 4, 100]join
join() 数组转换为字符串，返回转换后的字符串(默认逗号分割，也可以自己指定分隔符)，不会改变原数组
const arr = [100, 2, 33, 4, 100]
// 把数组转换为字符串，返回转换后的字符串，不会改变原数组
let str = arr.join('-')
console.log(str) // 100-2-33-4-100
// 不会改变原数组
console.log(arr) // [100, 2, 33, 4, 100]concat
concat() 连接一个或多个数组，返回拼接后的新数组，不会改变原数组
const arr1 = [100, 2, 33, 4, 100]
const arr2 = [200, 201, 202]
// 连接一个或多个数组，返回连接后的新数组，不会改变原数组
const newArr = arr1.concat(arr2)
console.log(newArr) // [100, 2, 33, 4, 100, 200, 201, 202]
// 不会改变原数组
console.log(arr1) // [100, 2, 33, 4, 100]slice
slice() 截取数组，截取不到末尾，返回截取后的新数组，不会改变原数组
const arr = [100, 2, 33, 4, 100]
// 截取数组，但是截取不到末尾，返回截取后的新数组
const newArr = arr.slice(3, 5)
console.log(newArr) // [4, 100]
// 如果只写一个参数，默认会截取它之后所有的(包含它)
console.log(arr.slice(1)) // [2, 33, 4, 100]
// 也可以接收一个负值
console.log(arr.slice(-2)) // [4, 100]
// 不会改变原数组
console.log(arr) // [100, 2, 33, 4, 100]includes
includes() 数组中是否包含某一项，包含的话，返回true，不包含的话，返回false
const arr = [100, 2, 33, 4, 100]
// 查看数组中是否包含某一项，包含的话返回true，不包含则返回false
const newArr = arr.includes(100)
console.log(newArr) // trueevery
every() 数组中的每一项是否都满足条件，只要有一项不满足，就返回false，如果都满足，返回true
const arr = [100, 2, 33, 4, 100]
// 数组中的每一项是否都满足条件，都满足返回true，只要有一项不满足，就返回false
let flag = arr.every(item => item > 5)
console.log(flag) // falsereduce
reduce((累计值，当前元素[，索引号][，源数组]) => { }，初始值) 累加器，返回函数累计处理的结果，经常用于求和
const arr = [100, 2, 33, 4, 100]
// 数组中的每一项是否都满足条件，都满足返回true，只要有一项不满足，就返回false
let res = arr.reduce((sum, item, index) => {
return sum += item
}, 0)
console.log(res) // 239splice
1. splice(开始索引，要删除的个数) 返回被删除的元素数组，会改变原数组
const arr = [100, 2, 33, 4]
// splice(开始索引,删除的个数) 返回被删除的元素
const newArr = arr.splice(0, 1)
console.log(newArr) // [100]
// 会改变原数组
console.log(arr) // [2, 33, 4]2. splice(开始索引，0，要添加的元素) 返回的是空数组，会改变原数组
const arr = [100, 2, 33, 4]
// splice(开始索引,0,要添加的元素) 返回的是空数组
const newArr = arr.splice(4, 0, 5)
console.log(newArr) // []
// 会改变原数组
console.log(arr) // [100, 2, 33, 4, 5]3. splice(第几个开始，1，替换的元素) 返回的是被替换的元素，会改变原数组
const arr = [100, 2, 33, 4]
// splice(开始索引,1,替换的元素) 返回的是被替换的元素数组
const newArr = arr.splice(3, 1, 444)
console.log(newArr) // [4]
// 会改变原数组
console.log(arr) // [100, 2, 33, 444]find
find() 按照条件筛选元素，返回满足条件的元素，没有满足条件的元素则返回undefined。不会改变原数组
const arr = [100, 2, 33, 4]
// 找到满足条件的元素，返回满足条件的元素
const newArr = arr.find(item => {
return item === 100
})
console.log(newArr) // 100
// 不会改变原数组
console.log(arr) // [100, 2, 33, 4]findIndex
findIndex() 按照条件筛选元素，如果有则返回下标，如果没有，则返回-1。不会改变原数组
const arr = [100, 2, 33, 4]
// 找到满足条件的元素，返回下标，没有则返回-1
const newArr = arr.findIndex(item => {
return item > 33
})
console.log(newArr) // 0
// 不会改变原数组
console.log(arr) // [100, 2, 33, 4]entries
entries() 会返回带有键/值对的Array Iterator对象，不会改变原数组
const arr = ['张三', '李四', '王五', '赵六']
// 返回带有键/值对的Array Iterator对象
const newArr = arr.entries()
console.log(newArr) // Array Iterator {}
for (const iterator of newArr) {
console.log(iterator) // [0, '张三'] [1, '李四'] [2, '王五'] [3, '赵六']
}
// 不会改变原数组
console.log(arr) // ['张三', '李四', '王五', '赵六']flat
flat() 会把传入的数组进行扁平化处理，把多维数组的变成一维数组。不会改变原数组
const arr = [1, [2, [3, [4, [5]]]]]
// 不传参数，默认就拉平1层
const arr1 = arr.flat()
console.log(arr1) // [1, 2, Array(2)]
// 传入Infinity，不管内部多少层，都会拉平成一维数组
const arr2 = arr.flat(Infinity)
console.log(arr2) // [1, 2, 3, 4, 5]原文链接：https://blog.csdn.net/qq_52845451/article/details/127000745
此处评论已关闭