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)