Array数组方法总结-CSDN博客

let arr1 = [1,2,3,4,5,6,7]
let arr2 = [7,8,9,4,5]
console.log(arr1)
console.log(arr2)
console.log('将arr2合并到arr1并且返回合并之后的数据',arr1.concat(arr2),'原数组为',arr1)

🥰2.join("分割符")方法---->使用分隔符，将数组转为字符串并且返回，分隔符默认为空---->原数组不会被改变

let arr1 = [1,2,3,4,5,6,7]
let arr2 = [7,8,9,4,5]
console.log(arr1)
// 2.join("分割符")方法---->使用分隔符，将数组转为字符串并且返回，分隔符默认为空---->原数组不会被改变
console.log("分隔符为|的时候",arr1.join('|'),'原数组为',arr1)
console.log("分隔符为''的时候",arr1.join(''),'原数组为',arr1)

😊3.pop()方法---->删除数组的最后一位元素，并且返回删除的数据---->原数组会被改变

let arr1 = [1,2,3,4,5,6,7]
console.log(arr1)
// 3.pop()方法---->删除数组的最后一位元素，并且返回删除的数据---->原数组会被改变
console.log('删除arr1数组的最后一位元素，并且返回删除的数据',arr1.pop(),'原数组为',arr1)

😊4.shift()方法---->删除数组的第一位元素，并且返回删除的数据---->原数组会被改变

let arr1 = [1,2,3,4,5,6,7]
console.log(arr1)
// 4.shift()方法---->删除数组的第一位元素，并且返回删除的数据---->原数组会被改变
console.log('删除arr1数组的第一位元素，并且返回删除的数据',arr1.shift(),'原数组为',arr1)

😊5.unshift()方法---->在数组的第一位新增一个或者多个元素，并且返回数组的长度---->原数组会被改变

let arr1 = [1,2,3,4,5,6,7]
console.log(arr1)
// 5.unshift()方法---->在数组的第一位新增一个或者多个元素，并且返回数组的长度---->原数组会被改变
console.log("增加一个元素并且返回的数组的长度",arr1.unshift('a'),'原数组为',arr1)
console.log("增加多个元素并且返回的数组的长度",arr1.unshift('study','school','night'),'原数组为',arr1)

🥰6.push()方法---->在数组的最后一位新增一个或者多个元素，并且返回数组的长度---->原数组会被改变

let arr1 = [1,2,3,4,5,6,7]
console.log(arr1)
console.log("增加一个元素并且返回的数组的长度",arr1.push('a'),'原数组为',arr1)
console.log("增加多个元素并且返回的数组的长度",arr1.push('study','school','night'),'原数组为',arr1)

🥰7.reverse()方法---->反转数组并且返回结果---->原数组会被改变

let arr1 = [1,2,3,4,5,6,7]
console.log(arr1)
// 7.reverse()方法---->反转数组并且返回结果---->原数组会被改变 
console.log("反转数组并且返回结果",arr1.reverse(),'原数组为',arr1)

🥰8.slice(索引号1，索引号2)方法---->截取开始位置索引（包含开始索引），截取结束位置索引（不包含结束位置），若是只写一个索引号则默认是从开始索引往后的所有元素---->原数组不会被改变

let arr1 = ['study','school','night','a','b']
console.log(arr1)
// 8.slice(索引号1，索引号2)方法---->截取指定位置的数组并且返回结果---->原数组不会被改变 
console.log(arr1.slice(0,2),'原数组为',arr1)
console.log(arr1.slice(2),'原数组为',arr1)

🥰9.sort()方法---->按照字符规则排序并且返回结果---->原数组会被改变

let arr1 = ['study','school','night','a','b']
console.log(arr1)
// 9.sort()方法---->按照字符规则排序并且返回结果---->原数组会被改变 
console.log(arr1.sort(),'原数组为',arr1)

🥰10.splice(指定位置)方法---->删除指定位置并且替换，然后返回删除的数据---->原数组会被改变

let arr1 = ['study','school','night','a','b']
console.log(arr1)
// 10.splice(起始位置（默认从0开始），删除几个元素（默认从1开始）)方法---->删除指定位置并且替换，然后返回删除的数据---->原数组会被改变 
console.log('删除指定位置的元素',arr1.splice(0,1),'原数组变成',arr1)

😊11.splice(起始位置（默认从0开始），删除几个元素（默认从1开始），在删除的元素前面添加元素)方法---->删除指定位置并且替换，然后返回删除的数据---->原数组会被改变

let arr1 = ['study','school','night','a','b']
console.log(arr1)
//11.splice(起始位置（默认从0开始），删除几个元素（默认从1开始），在删除的元素前面添加元素)方法---->删除指定位置并且替换，然后返回删除的数据---->原数组会被改变 
console.log('删除指定位置的元素',arr1.splice(0,1,'我是添加的元素'),'原数组变成',arr1)

😊12.toString()方法---->直接转换成字符串并且返回--->原数组不会被改变

let arr1 = ['study','school','night','a','b']
console.log(arr1)
// 12.toString()方法---->直接转换成字符串并且返回--->原数组不会被改变
console.log('直接转换成字符串并且返回',arr1.toString(),'原数组不变',arr1)

😊13.valueOf()方法---->返回数组对象的原始值--->原数组不会被改变

let arr1 = ['study','school','night','a','b']
console.log(arr1)
// 13.valueOf()方法---->返回数组对象的原始值--->原数组不会被改变 
console.log('返回数组对象的原始值',arr1.valueOf(),'原数组不变',arr1)

😊14.delete 数组[index]---->删除指定元素但是保留自身，返回null--->原数组会被改变

let arr1 = ['study','school','night','a','b']
console.log(arr1)
// 14.delete 数组[index]---->删除指定元素但是保留自身，返回null--->原数组不会被改变 
console.log('删除指定元素但是保留自身，返回null',delete arr1 [2],'原数组为',arr1)

🥰15.数组的增加和改动---->通过更改数组长度来增加数组元素（未给值则是undefined）；通过数组索引来增加元素（本来没有是增加元素，本来有则是替换改动元素)--->原数组会被改变

let arr1 = ['study','school','night','a','b']
console.log(arr1)
// 15.数组的增加和改动---->通过更改数组长度来增加数组元素；通过数组索引来增加元素（本来没有是增加元素，本来有则是替换改动元素)--->原数组会被改变 
console.log('数组长度为',arr1.length = 7,'，','原数组为',arr1)
console.log('更改数组索引，当前索引已有元素，所以会被替换掉',arr1[3] = '我是替换元素','，','原数组为',arr1)
console.log('更改数组索引，当前索引没有元素，所以是追加',arr1[7] = '我是追加元素','，','原数组为',arr1)

🥰16.数组的查询---->通过数组索引来查询元素--->原数组不会被改变

let arr1 = ['study','school','night','a','b']
console.log(arr1)
// 16.数组的查询---->通过数组索引来查询元素--->原数组不会被改变 
console.log('查询索引为2的数组元素是',arr1[2],'，','原数组为',arr1)

😊17.indexOf(想要查找的值如果是字符串则用引号包裹起来)方法---->查找数组中是否存在这个元素，存在则返回第一次出现时的索引，不存在则返回-1(这个方法可以用于数组去重)--->原数组不会被改变

let arr1 = ['study','school','night','a','b']
console.log(arr1)
// 17.indexOf(想要查找的值字符串用引号包裹起来)方法---->查找数组中是否存在这个元素，存在则返回第一次出现时的索引，不存在则返回-1(这个方法可以用于数组去重)--->原数组不会被改变
console.log('查找数组中是否存在这个元素并且存在则返回元素本身的索引',arr1.indexOf('school'),'，','原数组为',arr1)
console.log('查找数组中是否存在这个元素并且返回索引,不存在返回的值为-1',arr1.indexOf('slice'),'，','原数组为',arr1)
//定义一个空数组用来添加
var arr2=[]
//遍历arr1的元素
for(let i =0 ;i < arr1.length ; i++){
//如果arr2中想要查找的值（arr1的元素）不存在则将这个值追加到arr2中
	if(arr2.indexOf(arr1[i]) === -1){
		//追加到新数组arr2中
			arr2.push(arr1[i])
	}
}
console.log('去重后原数组为',arr2)

😊18.lastIndexOf(想要查找的值如果是字符串则用引号包裹起来)方法（从后往前查找）---->查找数组中是否存在这个元素，存在则返回第一次出现时的索引，不存在则返回-1(这个方法可以用于数组去重)--->原数组不会被改变 ---->类似于indexOf()方法

let arr1 = ['study','school','night','a','b','a','study']
console.log(arr1)
// 18.lastIndexOf(想要查找的值如果是字符串则用引号包裹起来)方法（从后往前查找）---->查找数组中是否存在这个元素，存在则返回第一次出现时的索引，不存在则返回-1(这个方法可以用于数组去重)--->原数组不会被改变   
console.log('查找数组中是否存在这个元素并且存在则返回元素本身的索引',arr1.lastIndexOf('school'),'，','原数组为',arr1)
console.log('查找数组中是否存在这个元素并且返回索引,不存在返回的值为-1',arr1.lastIndexOf('slice'),'，','原数组为',arr1)

😊19.includes(元素值)方法（从后往前查找）---->检查数组是否包含指定元素存在则返回第一次出现时的索引，不存在则返回-1--->原数组不会被改变

let arr1 = ['study','school','night','a','b','a','study']
console.log(arr1)
// 19.includes(元素值)方法（从后往前查找）---->检查数组是否包含指定元素--->原数组不会被改变   
console.log('检查数组是否包含指定元素school',arr1.lastIndexOf('school'),'，','原数组为',arr1)
console.log('检查数组是否包含指定元素slice',arr1.lastIndexOf('slice'),'，','原数组为',arr1)

🥰20.forEach( (item,[index]) => 回调函数业务逻辑代码)---->遍历数组对每个元素执行指定的回调函数（或者说用于调用数组的每个元素，并将元素传递给回调函数（用于查找遍历数组元素，替代for循环））--->原数组不会被改变

let arr1 = ['study','school','night','a','b','a','study']
console.log(arr1)
// 20.forEach( (item,index) => 回调函数业务逻辑代码)---->遍历数组对每个元素执行指定的回调函数，并且forEach没有返回值--->原数组不会被改变 
//forEach遍历每个元素
const res = arr1.forEach((item,index) => console.log(item,index))
console.log(res,arr1) //没有返回值

🥰21.filter( (item,[index]) => 回调函数业务逻辑代码)---->用于过滤数组单元值，生成新数组--->原数组不会被改变

let arr1 = [10,20,30,60,80,1,]
console.log(arr1)
// 21.filter( (item,index) => 回调函数业务逻辑代码)---->用于过滤数组单元值，生成新数组--->原数组会被改变 
const res = arr1.filter((item,index) => const res = arr1.filter((item) => item > 20)
console.log(res,arr1)

🥰22.map( (item,[index]) => 回调函数业务逻辑代码)---->迭代原数组，返回新数组（处理之后的数组元素）映射--->原数组不会被改变

let arr1 = [10,20,30,60,80,1,]
console.log(arr1)
// 22.map( (item,index) => 回调函数业务逻辑代码)---->迭代原数组，返回新数组（处理之后的数组元素）映射--->原数组会被改变 
console.log(arr1.map((item) => item*2 )，arr1)

🥰23.find( (item,[index]) => 回调函数业务逻辑代码)---->查找元素，返回符合测试条件的第一个数组元素值，如果没有符合的则返回undefined--->原数组不会被改变

let arr1 = [10,20,30,60,80,1,]
console.log(arr1)
// 23.find( (item,[index]) => 回调函数业务逻辑代码)---->查找元素，返回符合测试条件的第一个数组元素值，如果没有符合的则返回undefined--->原数组不会被改变 
console.log(arr1.find((item,index) => item > 20 ),arr1)

🥰24.reduce( (pre,item) => 回调函数业务逻辑代码,pre)---->累计器（没有起始值pre则上一次的值为数组第一个元素的值，每一次循环都是把返回值作为下一次循环的上一次值，如果有起始值，则起始值为上一次值），有初始值遍历次数与数组元素相同，没有初始值则循环次数比数组元素少1 --->原数组不会被改变

let arr1 = [10,20,30,60,80,1,]
console.log(arr1)
// 24.reduce( (pre,item) => 回调函数业务逻辑代码,pre)---->累计器（没有起始值pre则上一次的值为数组第一个元素的值，每一次循环都是把返回值作为下一次循环的上一次值，如果有起始值，则起始值为上一次值），有初始值遍历次数与数组元素相同，没有初始值则循环次数比数组元素少1 --->原数组不会被改变
console.log(arr1.reduce((pre,item) => pre + item  ),arr1)

🥰25.every( (item,[index]) => 回调函数业务逻辑代码)---->检测数组中所有元素是否都符合指定条件，如果所有元素都满足则返回true，否则返回false--->原数组不会被改变

let arr1 = [10,20,30,60,80,1,]
console.log(arr1)
// 25.every( (item,[index]) => 回调函数业务逻辑代码)---->检测数组中所有元素是否都符合指定条件，如果所有元素都满足则返回true，否则返回false--->原数组不会被改变 
console.log(arr1.every((item) => item>20 ),arr1)  //false
console.log(arr1.every((item) => item>0 ),arr1) //true

🥰26.some( (item,[index]) => 回调函数业务逻辑代码)---->检测数组中是否有元素符合指定条件，如果有元素满足则返回true，否则返回false--->原数组不会被改变

let arr1 = [10,20,30,60,80,1,]
console.log(arr1)
// 26.some( (item,[index]) => 回调函数业务逻辑代码)---->检测数组中是否有元素符合指定条件，如果有元素满足则返回true，否则返回false--->原数组不会被改变 
console.log(arr1.some((item) => item>20 ),arr1)  //true
console.log(arr1.every((item) => item>100 ),arr1) //false

🥰27.findIndex( (item,[index]) => 回调函数业务逻辑代码)---->查找元素的索引值--->原数组不会被改变

let arr1 = [10,20,30,60,80,1,]
console.log(arr1)
// 27.findIndex( (item,[index]) => 回调函数业务逻辑代码)---->查找元素的索引值--->原数组不会被改变  
console.log(arr1.findIndex((item) => item === 20 ),arr1)

😊28.fill(value,起始索引（默认为 `0`）,终止索引（默认为 `array.length`）)---->用一个固定值填充一个数组中从起始索引到终止索引内的全部元素,返回修改后的数组--->原数组会被改变

let arr1 = [10,20,30,60,80,1,]
console.log(arr1)
// 28.fill(value,start,end)---->用一个固定值填充一个数组中从起始索引（默认为 0）到终止索引（默认为 array.length）内的全部元素,返回修改后的数组--->原数组会被改变 
console.log(arr1.fill(6 ),arr1)
console.log(arr1.fill(2,3,6 ),arr1)
console.log(arr1.fill(2,3 ),arr1)

😊29.flat(depth深度)方法---->创建一个新的数组，并根据指定深度递归地将所有子数组元素拼接到新的数组中--->原数组会被改变

let arr1 = [10,20,30,[60,80,1,6]]
console.log(arr1)
const arr2 = [0, 1, [2, [3, [4, 5]]]];
console.log(arr2)
// 29.flat()方法---->创建一个新的数组，并根据指定深度递归地将所有子数组元素拼接到新的数组中--->原数组会被改变
console.log(arr1.flat(),arr1) //双重数组，深度depth为2
console.log(arr2.flat(3),arr1) //三重数组，深度depth为3
console.log(arr2.flat(Infinity)) //全局属性 Infinity 是一个数值，表示无穷大