JavaScript操作数组的常用方法
#JavaScript操作数组的常用方法
- push()：在数组的末尾添加一个或多个元素，并返回新的长度。
- pop()：移除并返回数组中的最后一个元素。
- shift()：移除并返回数组中的第一个元素。
- unshift()：在数组的开头添加一个或多个元素，并返回新的长度。
- splice()：从数组中添加或删除元素。
- slice()：返回数组的指定部分，不会改变原数组。
- concat()：将两个或多个数组合并成一个新数组，不会改变原数组。
- reverse()：反转数组中的元素，改变原数组。
- sort()：对数组元素进行排序，改变原数组。
- indexOf()：返回指定元素在数组中第一次出现的位置，未找到返回 -1。
- lastIndexOf()：返回指定元素在数组中最后一次出现的位置，未找到返回 -1。
- join() 把数组中的所有元素转换为一个字符串
- split() 把一个字符串分割成字符串数组:
- every()：检测数组中所有元素是否符合指定条件，如果全部符合则返回
true，否则返回false。 - some()：检测数组中是否有元素符合指定条件，如果有则返回
true，否则返回false。 - forEach()：对数组中的每个元素执行指定操作。
- map()：对数组中的每个元素执行指定操作，返回一个新数组。
- filter()：对数组中的每个元素进行测试，并返回一个新数组，该数组包含所有测试通过的元素。
- reduce()：对数组中的每个元素执行指定操作，返回一个累计值。
- reduceRight()：对数组中的每个元素从右到左执行指定操作，返回一个累计值。
- find()：查找符合条件的第一个元素，并返回该元素。
- findIndex()：返回符合条件的第一个元素在数组中的位置，未找到返回 -1。
- fill()：使用指定的值填充数组中从起始索引到终止索引内的所有元素。
- includes()：检测数组是否包含指定元素，如果存在则返回
true，否则返回false。 - flat()：将数组展开一层，返回一个新数组。
- flatMap()：对数组中的每个元素执行指定操作，并展开结果为一维数组。
- copyWithin()：将数组中指定位置的元素复制到另一个指定位置，返回改变后的数组。
// push()：在数组的末尾添加一个或多个元素，并返回新的长度。
let arr = [1, 2, 3, 4, 5, 6]
let a = arr.push(1, 2, 3)
console.log(arr, a)
//pop()：移除并返回数组中的最后一个元素。
let brr = [1, 2, 3, 4, 5]
const b = brr.pop()
console.log(brr, b)
//shift()：移除并返回数组中的第一个元素。
let crr = [1, 2, 3, 4, 5]
const c = crr.shift()
console.log(crr, c)
//unshift()：在数组的开头添加一个或多个元素，并返回新的长度。
let drr = [1, 2, 3, 4, 5]
const d = drr.unshift(1, 2, 3, 4)
console.log(drr, d)
//splice()：从数组中添加或删除元素。改变元素
let err = [1, 2, 4, 5, 6]
//删除并返回删除的元素
const e = err.splice(0, 2) //从第一个元素开始删除两位
console.log(err, e)
//添加元素返回空数组
const e1 = err.splice(2, 0, 12, 22) //从第三个元素开始删除零个元素
console.log(err, e1)
//slice()：返回数组的指定部分，不会改变原数组。
let frr = [1, 3, 4, 2, 1, 3, 4]
const f = frr.slice(1, 4)
console.log(frr, f)
//concat()：将两个或多个数组合并成一个新数组，不会改变原数组。
let grr = ['a', 'd', 'f', 'q']
let grr1 = ['m', 'n', 'j']
const grr2 = grr.concat(grr1)
console.log(grr, grr1, grr2)
//reverse()：反转数组中的元素，改变原数组。
let hrr = ['w', 'e', 't', 'y', 'v', 'h']
hrr.reverse()
console.log(hrr)
//sort()：对数组元素进行排序，改变原数组。
let Irr = [2, 3, 4, 2, 1, 56, 23, 66]
Irr.sort(function(a, b) { //参数可选，必须是函数。规定排序顺序
return b - a
})
console.log(Irr)
// indexOf()：返回指定元素在数组中第一次出现的位置，未找到返回 -1。
let Jrr = [1, 2, 3, 4, 3, 2, 1, 4, 5]
const j = Jrr.indexOf(4)
const j1 = Jrr.indexOf(10)
console.log(j, j1)
//lastIndexOf()：返回指定元素在数组中最后一次出现的位置，未找到返回 -1。
let Krr = [1, 2, 3, 4, 5, 3, 34, 1]
const k = Krr.lastIndexOf(3)
const k1 = Krr.lastIndexOf(10)
console.log(k, k1)
//join() 把数组中的所有元素转换为一个字符串：
let oi = [1, 2, 3, 4]
const io = oi.join('-')
console.log(io)
//split() 把一个字符串分割成字符串数组:
let str = 'number is five'
const Str = str.split(' ')
console.log(Str)
//every()：检测数组中所有元素是否符合指定条件，如果全部符合则返回 `true`，否则返回 `false`。
let num = [1, 32, 45, 33, 44, 66, 35, 76]
const n = num.every((item, index) => {
console.log(item)
return item >= 1
})
console.log(num, n)
//some()：检测数组中是否有元素符合指定条件，如果有则返回 `true`，否则返回 `false`。
let Prr = [34, 5, 6, 23, 43, 56, 64, 37, 46]
const p = Prr.some((item, index) => {
console.log(item, index)
return item > 50
})
console.log(Prr, p)
// forEach()：对数组中的每个元素执行指定操作。返回值Undefined
let Orr = [21, 34, 53, 23, 4, 56, 78]
Orr.forEach((item, index) => {
console.log(item, index)
})
//map()：对数组中的每个元素执行指定操作，返回一个新数组。不会对空数组检查，返回原数组
let Mrr = [2, 3, 4, 23, 4, 54, 67, 54, 32]
let M = Mrr.map((item, index) => {
return item + 1
})
console.log(Mrr, M)
//filter()：对数组中的每个元素进行测试，并返回一个新数组，该数组包含所有测试通过的元素。
let Lrr = [1, 2, 3, 3, 23, 54, 65, 77]
let L = Lrr.filter((item, index) => {
return item <= 3
})
console.log(L, Lrr)
//reduce()：对数组中的每个元素执行指定操作，返回一个累计值。
let Wrr = [1, 3, 45, 3, 21, 45]
const w = Wrr.reduce((c, d) => { //接收四个参数，初始值，当前值，当前索引，当前数组对象
return c + d
})
console.log(w)
//reduceRight()：对数组中的每个元素从右到左执行指定操作，返回一个累计值。
let WrrR = [1, 3, 45, 3, 21, 45]
const wR = Wrr.reduce((c, d) => { //接收四个参数，初始值，当前值，当前索引，当前数组对象
return c + d
})
console.log(wR)
// find()：查找符合条件的第一个元素，并返回该元素。
let Zrr = [1, 2, 3, 2, 4, 5]
const Z = Zrr.find((item, index) => {
return item > 4
})
console.log(Z)
//findIndex()：返回符合条件的第一个元素在数组中的位置，未找到返回 -1。
let ZrrI = [1, 2, 3, 2, 4, 5]
const Zi = ZrrI.findIndex((item, index) => {
return item > 1
})
const Zii = ZrrI.findIndex((item, index) => {
return item > 5
})
console.log(Zi, Zii)
//fill()：使用指定的值填充数组中从起始索引到终止索引内的所有元素。
let Yrr = [1, 2, 2, 2, 3, 4, 5, 6]
const Yrr1 = Yrr.fill(9, 1, 4) //value,start,end
console.log(Yrr, Yrr1)
//includes()：检测数组是否包含指定元素，如果存在则返回 `true`，否则返回 `false`。
let Rrr = [1, 2, 3, 4, 5]
const R = Rrr.includes(3)
console.log(R)
//flat()：将数组展开一层，返回一个新数组。
let Urr = [1, 2, 3, [2, 3, 4, 23, 4]]
const newUrr = Urr.flat()
console.log(newUrr)
//flatMap()：对数组中的每个元素执行指定操作，并展开结果为一维数组。
let D = [1, 2, 3, 6]
const Dr = D.flatMap((item, index) => {
return item * 2
})
console.log(Dr)
//copyWithin()：将数组中指定位置的元素复制到另一个指定位置，返回改变后的数组。
let fruits = ["Banana", "Orange", "Apple", "Mango"];
const fi = fruits.copyWithin(2, 0); //第一个参数，复制到指定的位置，第二个参数 元素复制的起始位置
console.log(fi)