数组合并concat,数组切片slice,event,循环遍历:map,forEach,筛选过滤:filter,查找:find,findIndex,reduce(),

数组合并

let arr = [1, 2, 3, 4, 5, 6, 7];
const result = arr.concat([4, 5, 6], 7, 8);
console.log(result);

数组剪切:slice(index1,index2)

取数组下标[index1,index2),index1的下标取,index2小标对应的数据不取

    let arr = [1, 2, 3, 4, 5, 6, 7];
  let result = arr.slice(1, 5);//[2,3,4,5]
        console.log(result);

数组判断:every,some

every:这是判断数据是否含有某个数据,只要有一个不成立就返回:false,要全部都符合才会返回true

 const arr = [1,2,3,4,5,1024];
  const result = arr.every(item => {
            return item >1;
    });
  console.log(result); //false

some:只要找到一个符合条件的，就回来报告true 所以并不会全部遍历，不做多余的活（性能优良）

  const arr = [1,2,3024,4,5,1024];
    const result = arr.some(item => {
            return item > 2000;
        });
  console.log(result);
  },

循环遍历:map,forEach

//map:
   let arr = [1, 2, 3, 4, 5, 1024];
    let newa = arr.map((item) => {
      return item + 1;
    });
    console.log(newa);// [2, 3, 4, 5, 6, 1025]
//forEach
  let arr = [1, 2, 3, 4, 5, 1024];
    let newa = arr.forEach((i,index) => {
     return item + 1
    });
    console.log(newa);//undefined

筛选过滤:filter

   let arr = [1, 2, 3, 4, 5, 1024];
    let newa = arr.filter((i,index) => {
     return item > 2
    });
    console.log(newa);//[3, 4, 5, 1024]

查找:find ,findIndex

//find:返回值
   let arr = [1, 2, 3, 4, 5, 1024];
    let newa = arr.find((item,index) => {
     return item > 3
    });
    console.log(newa);//4

//findIndex:返回下标
    let arr = [1, 2, 3, 4, 5, 1024];
    let newa = arr.findIndex((item,index) => {
     return item > 3
    });
    console.log(newa);//3(下标)

reduce()

reduce 为数组中的每一个元素依次执行回调函数，不包括数组中被删除或从未被赋值的元素，接受四个参数：初始值（或者上一次回调函数的返回值），当前元素值，当前索引，调用 reduce 的数组。

1、previousValue =>初始值或上一次回调函数叠加的值；
2、currentValue => 本次回调（循环）将要执行的值；
3、index=>“currentValue”的索引值；
4、arr => 数组本身；

第一种情况:没有设置初始值

遍历是重下标为1开始

   let arr = [1, 2, 3, 4, 5];
    let newa = arr.reduce((prev, cur, index, arr) => {
        console.log(prev, cur, index);
     return prev * cur;
    });
    console.log('最后结果',newa);
    // 1 2 1
    // 2 3 2
    // 6 4 3
    // 24 5 4
    // 最后结果 120

第二种:设置初始值

下标是从0开始

let arr = [1, 2, 3, 4, 5];
let newa = arr.reduce((prev, cur, index, arr) => {
console.log(prev, cur, index);
return prev * cur;
},2);//注意这里设置了初始值
console.log(‘最后结果’,newa);
// 2 1 0
// 2 2 1
// 4 3 2
// 12 4 3
// 48 5 4
// 最后结果 240

通常我们使用reduc会设置初始值,这样的话会更好,防止出现空数组报错

reduce的计算输出元素出现的次数

let arr = [1, 2, 3, 3, 2, 2];
let newa = arr.reduce((prev, cur, index, arr) => {
if (cur in prev) {
prev[cur]++;
} else {
prev[cur] = 1;
}
return prev;
}, {}); //注意这里初始值返回对象
console.log(“最后结果”, newa);//最后结果 {1: 1, 2: 3, 3: 2}

把二维数组转换为一维

let arr = [[1, 2], 3, 3, [2, 2]];
    let newa = arr.reduce((prev, cur, index, arr) => {
   return prev.concat(cur)
    }, []); //注意这里初始值返回数组
    console.log("最后结果", newa);//最后结果 (6) [1, 2, 3, 3, 2, 2]
    

把多维数组转化为一维:可以封装为方法,直接请求

   let arr = [[1, 2], 3, [3, [2, 2]]];
    let newArr =function(arr){
   return arr.reduce((pre,cur)=>pre.concat(Array.isArray(cur)?newArr(cur):cur),[])
}
    console.log("最后结果", newArr(arr));//最后结果 (6) [1, 2, 3, 3, 2, 2]

还可以对数组对象转变为数组,或者数组对象的求和,返回数组对象中符合条件的对象组成新数组

   let result = [
      {
        subject: "a",
        score: 10,
      },
      {
        subject: "b",
        score: 20,
      },
      {
        subject: "c",
        score: 40,
      },
    ];
    let sum = result.reduce(function (prev, cur) {
      return prev.concat(cur.subject);
    }, []);
    console.log(sum);//["a", "b", "c"]