JS数组方法总结

改变原数组的方法

1.push末尾增加

功能：在数组的末尾增加一个或多个元素 arr.push(1,2,3,4) 参数：写几个参数就增加几个 返回值：增加完元素后最新的长度

2.pop末尾删除

功能：在数组的末尾删除一个元素 arr.pop() 参数：无 返回值：返回删除的那一个元素

3.unshift头部添加

功能：在数组的头部添加一个或多个元素 arr.unshift(2,4) 参数：无 返回值：返回增加完元素之后最新的数组长度

4.shift头部删除

功能：在数组的头部删除一个元素 arr.shift(2,4) 参数：无 返回值：返回删除的那一个元素

5.splice增删改

功能：任意位置 增 删 改

功能：删除
参数：第一个代表起始下标，第二个代表要删除的长度 arr.splice(2,4) 从起始下标开始（包括起始下标）删除挨着的4个元素
返回值：是删除元素组成的数组  //若第二个参数为0 ，则返回空数组

功能：增加
参数：第一个代表起始下标，第二个删除长度为0 ，后续写的就是要增加的数组成员
返回值：空数组  ，原数组已经添加成功

功能：修改
参数：第一个代表起始下标，第二个要删除的长度 ，后续写的就是要增加的数组成员
返回值：是删除元素组成的数组  ，原数组已经修改

6.sort 排序

功能：对数组排序 （默认排序顺序是将原数组成员转换为字符串，根据字符串Unicode码点） 参数：如果参数是一个compareFunction，那么数组会按照调用该函数的返回值排序： 如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前 如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变(有可能某些浏览器不支持) 如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前 比较数字简写：numbers.sort((a, b) => a - b) 升序，反之降序

返回值： 排好序的数组

7.reverse反转

功能：反转数组 arr.reverse() 参数：无 返回值：反转之后的数组

8.fill 填充每个

功能：将数组中的每个元素都替换为指定的值 arr.fill(100) 参数：第①个参数指定的值，第②个参数写小于等于数组长度的数字，写2代表数字0，1两个成员不会被填充 返回值：填充后的数组

不改变原数组的方法

1.join 链接数组成员

功能：定的连接符连接数组中的数据 arr.join('+') 参数：空串‘’，或者指定连接符 返回值：连接后的字符串，①不写参数，是以逗号隔开的原数组成员；②空串，则是原数组元素；

2.forEach 遍历

功能：遍历数组 arr.forEach((item,index)=>{...}) 参数：函数，形参可以写两个，分别表示数组当中每个元素和每个元素对应的下标 返回值：undefined

3.filter 过滤

功能：过滤出来一个新数组 arr.filter((item,index,arr)=>{ return 条件表达式}) 暗含遍历 参数：一个函数 函数的形参可以拿到元素和下标 第三个参数 是数组 返回值：过滤出符合条件的元素组成的数组 满足条件的数组

4.map 映射

功能：映射出来一个新数组 arr.map((item,index)=>{ return 表达式}) 暗含遍历 参数：一个函数 函数的形参可以拿到元素和下标 返回值：一个新的数组 数组成员取决于 return 表达式的值

5.every 判断全部

功能：判断数组当中的每一项是否都符合条件 arr.every((item,index)=>{ return 条件表达式}) 暗含遍历 参数：一个函数 函数的形参可以拿到元素item和下标 index 返回值：全部满足条件为true，有一个不满足则为false， 运行次数不确定，一旦遇到不满足条件的 那么到此结束

6.some 判断某个

功能：判断数组当中的某一个元素是否符合条件 arr.some((item,index)=>{ return 条件表达式}) 暗含遍历 参数：一个函数 函数的形参可以拿到元素item和下标 index 返回值：有一个满足条件则为true，全不满足则为false， 运行次数不确定，一旦遇到一个满足条件的 那么到此结束

7.flat 拉平数组

功能：将多维数组拉平 arr2.flat(Infinity) 参数：参数指定拉多少层，默认值是1，可以设置为 Infinity 表示任意层。 ES2019 返回值：返回拉平后的数组

8.includes 是否包含

功能：判断是否是否包含某个元素 arr2.includes (item,2) 参数：第①个为要查找的数组成员，第②个指定开始查找的位置 返回值：有则为true ，无则为false

9.find 查找符合

功能：查找数组当中符合这个条件的第一个元素 arr.find((item,index)=>{ return 条件表达式}) 暗含遍历 参数：一个函数 函数的形参可以拿到元素item和下标 index 返回值：如果多个返回第一个满足条件的元素，若是都没有则返回undefined， 运行次数不确定，一旦遇到一个满足条件的 那么到此结束

10.findIndex() 查找符合

功能：返回第一个满足条件的元素的索引 arr.findIndex((item,index)=>{ return 条件表达式}) 暗含遍历 参数：一个函数 函数的形参可以拿到元素item和下标 index 返回值：返回第一个满足条件的元素的索引，都没有则返回 -1

11.reduce 累加器

正常情况

功能：累加 暗含遍历 参数：①一个函数 ：三个行参 上一次的值prev，每项元素item，每项元素下；②初始值 0，首次执行时初始值会给prev赋值 prev之后每次的值取决于return的值 返回值：累加之后的结果 如果只返回item 他是返回数组中最后一个的

特殊情况

功能：累加 暗含遍历 参数：①一个函数 ：三个行参 上一次的值prev，每项元素item，每项元素下； 不写初始值的情况 执行过程 ： prev拿数组当中的第一项做为初始值 item从数组第二项开始遍历； 返回值：累加之后的结果 如果只返回item 他是返回数组中最后一个的

12.slice指定截取

功能：截取指定的元素 arr.slice() 参数：第一个为起始下标，第二个为结束下标 [start，end)，1个参数默认起始下标，截取至末尾 返回值：截取到的元素组成的数组

13.concat 拼接

功能：接数组或者数组当中拼接元素 arr.concat[12] arr.concat[[1,2,3]] 参数：可以是元素 也可以是数组 返回值：拼接完后的数组

14.toString 数组转字符

功能：把数组变成字符串 arr.toString() 参数：无 返回值：数组中的内容以逗号隔开的字符串 （如果成员是对象，则返回这样的[object Object]；还是数组，则摊开；是函数，则函数整体）

15.indexof 查找某个

功能：在数组当中查找有没有某个元素 arr.indexof(1) 参数：可以写两个 ，第①个参数代表你要查找的子串内容， 第②个参数代表你要从哪个下标开始查 返回值：找到了返回元素的下标，找不到返回-1

16.lastIndexOf查找最后一个

功能：在数组当中查找有没有某个元素 arr.lastIndexOf(1) 参数：要查找的内容 返回值：找到了返回最后一个满足的元素的下标，找不到返回-1

Array 构造函数本身新增的方法

Array.of()      创建新数组，参数会作为数组中的元素，参数数量可以是任意个    
Array.from()    将伪数组转为纯数组
Array.isArray()  判断是不是一个数组

数组方法手写

1.求数组最大值，最小值，平均值

let arr= [987, 56, 1230, 456]
let max=arr[0],min=arr[0],add=0
for(let i=1;i<arr.length;i++){
    if(max<arr[i]){ //最大值
        max=arr[i]
    }
    if(min>arr[i]){ //最小值
       min =arr[i]
    }
    add+=arr[i]//求和
}

2.合并数组

//concat  接数组或者数组当中拼接元素 `arr.concat[12] arr.concat[[1,2,3]]` 
let arr1 = [1, 3, 5, 7],arr2 = [2, 4, 6, 8]
for(let i=0;i<arr2.length;i++){
    arr1[arr1.length]=arr2[i]
}

3.反转数组

//反转数组   `arr.reverse()`
//在原数组中反转
let arr = [1, 3, 5, 7, 9]
for(let i=0;i<arr.length/2;i++){
    let temp=arr[i]  //定义一个变量 用于两个变量交换值
    arr[i]=arr[arr.length-1-i]
    arr[arr.length-1-i]=temp
}
//在新数组当中反转
let newArr=[]
for(let i=arr.length-1;i>=0;i--){
    newArr[newArr.length]=arr[i]
}

4.数组去重

//Set构造函数 新增的数据类型，类似于数组，但是里面的成员的值不能重复，必须是唯一； 相比于数组没有索引结构。 
let arr = [1, 3, 5, 5, 7, 7, 9]
let newArr=[]
let flag=true //标志位思想
for(let i=0;i<arr.length;i++){
    for(let j=0;j<newArr.length;j++){
        if(arr[i]==newArr[j]){//只要有一个等的就代表有重复，但是用不等的话 没法确定，因为必须每次一轮里全不等才能确定！
          flag=false   
           break //跳出这轮循环
        }
    }
    // i=0时，内层循环不满足条件不执行，直接到这里 
    // 内层循环有重复，break后，走到这里 flag变false；
    // 执行完内层for循环后，没有碰到break，到这里
    if(flag){
        newArr[newArr.length]=arr[i]
    }
    flag=true //重置flag
}

5.冒泡排序

//6.sort 排序 
let arr = [47, 65, 12, 78, 3]
for(let i=0;i<arr.length-1;i++){ //最后一个不用比所以-1
    for(let j=0;j<arr.length-1-i;j++){
        if(arr[j]>arr[j+1]){
            let temp=arr[j+1]//交换变量
            arr[j+1]=arr[j]
            arr[j]=temp
        }
    }
}

\