javascript中ES5数组方法

【1】：map方法 映射数组

• arr.map(callback) callback里面有三个参数
  • callback参数1：items —原始数组的每一个元素
  • callback参数2：i —原始数组的每一个元素对应的索引号
  • callback参数3：arr —原始数组
  • 作用：就是对数组进行修改后，不改变原始数组，
  • 返回值：return 表达式后面的操作，返回到一个新数组！
  • 常常使用的是：遍历原始数组，针对每一个数组元素进行修改后，返回一个新的数组！

    let arr = [1, 3, 5, 7, 9]
    let res = arr.map(function (items, i, arr) {
      return items * 2;
    })
    console.log(res); //[2, 6, 10, 14, 18]
    console.log(arr); //[1, 3, 5, 7, 9]

【2】：forEach()方法

• arr.forEach(callback)
  • callback参数1：items —原始数组的每一个元素
  • bcallback参数2：i —原始数组的每一个元素对应的索引号
  • callback参数3：arr —原始数组
  • 作用：就是遍历原始数组，不对数组做任何改变
  • 注意点：forEach方法里面是没有数组长度的，不能中断循环，也就是说，不能添加break，continue
  • 注意点2：forEach方法里面是没有return

    let arr = [1, 3, 5, 7, 9]
    arr.forEach(function (items, i, arr) {
      console.log(items); //数组中每一项元素
      console.log(i); //对应的索引号
      console.log(arr); // [1, 3, 5, 7, 9]
    })

【3】 arr.filter方法

• arr.filter(callback)
  • callback参数1：items —原始数组的每一个元素
  • bcallback参数2：i —原始数组的每一个元素对应的索引号
  • callback参数3：arr —原始数组
  • 作用：就是遍历原始数组，根据要求，过滤掉符合的数组元素，不会修改原始数组
  • 返回值：过滤掉符合的数组元素存储在新数组的上
  • 常常使用的是：遍历原始数组，然后根据特点的需求，寻找到符合条件的元素，这这些符合的元素一一过滤出来后，放置在一个新数组当中
    还有某些元素的价格大于100，还有其他什么的

	// 简单的过滤
    let arr = [1, 3, 5, 7, 9]
    let res = arr.filter(function (items, i, arr) {
      return items > 5
    })
    console.log(arr); //[1, 3, 5, 7, 9]
    console.log(res); //[7, 9]

    //需求2：去掉数组中重复的元素
    let arr1 = [1, 3, 5, 7, 3, 6]
    let arr2 = [1, 3, 5, 8, 5, 3, 99, 33]
    let res = arr1.filter(function (items, i) {
      return (arr2.indexOf(items) !== -1)
    })
    console.log(res); //res这个数组有交集 数组的去重  [1, 3, 5, 3]
  // 找两个数组对象之中的 共同属性交集
let a=[{id:1,a:123,b:1234},{id:2,a:123,b:1234}];
let b=[{id:1,a:123,b:1234},{id:2,a:123,b:1234},{id:3,a:123,b:1234},{id:4,a:123,b:1234}];
let arr = [...b].filter(x => [...a].some(y => y.id === x.id));
console.log('arr',arr)

【4】:arr.some方法

• arr.some(callback)
  • callback参数1：items —原始数组的每一个元素
  • bcallback参数2：i —原始数组的每一个元素对应的索引号
  • callback参数3：arr —原始数组
  • 作用：就是遍历原始数组，根据要求,符合条件后，返回一个布尔值，但是不会改变原始数组
  • 返回值：布尔值
  • 常常使用的是：遍历原始数组，判断原始数组里面是否有一个符合条件的元素，若是符合就为true,若是不符合就为false

    let arr = [1, 3, 5, 7, 9];
    let res = arr.some(function (items, i) {
      return items > 5
    })
    console.log(res); //true
    console.log(arr); //[1, 3, 5, 7, 9]

【5】:arr.every方法

• arr.every(callback)
  • callback参数1：items —原始数组的每一个元素
  • bcallback参数2：i —原始数组的每一个元素对应的索引号
  • callback参数3：arr —原始数组
  • 作用：就是遍历原始数组，根据要求,全部符合条件后，返回一个布尔值，但是不会改变原始数组
  • 返回值：布尔值（假如有一个不符合条件就是为false，假如全部符合后，就返回true）

    let arr = [1, 3, 5, 7, 9];
    let res = arr.every(function (items, i) {
      return items > 5
    })
    console.log(res); //false
    console.log(arr); //[1, 3, 5, 7, 9]

【6】：arr.reduce方法

• arr.reduce(callback(){},参数2) reduce方法的参数为两个，一个callback，一个是参数2
  • 注意点：参数2主要是给pre这个初始值赋值（最初的赋值，默认为数组的第一个数据）
  • callback的参数1：pre为上一次执行返回的值，最初是的状态是一个变量，第一次循环pre的值为参数2赋值过来的1
  • callback参数2：为cur当前的值 每次循环时 数组里面对应的数据
  • 作用：可以用于求和，可以用于查询一个数组中是否含有另一个数组的元素，不会修改原始数组
  • 返回值：返回的是return 后面符合条件的表达式的返回值！形成一个新的数组
  • 常常的使用的是：可以使用reduce来实现求和，还有使用reduce来实现数组的去重
    数组的去重的话：就是给初始值pre赋值一个数组，然后使用这个cur接受原始数组的元素，来pre数组中查询，若是存在这个元素就是直接返回原数组，若是不存在就直接拼接在pre数组身上（需要使用到pre.concat(cur)方法)

// 需求0 一个数组之中 去掉重复的对象
      obj: [ { value: "111", name: "我是菜鸡1", },
        {  value: "222", name: "我是菜鸡2", },
        { value: "333", name: "我是菜鸡3", },
        { value: "444", name: "我是菜鸡4",},
        { value: "111", name: "我是菜鸡1",},
      ],
    let obj = {};
    let res = this.obj.reduce(function (item, next) {
      obj[next.value] ? "" : (obj[next.value] = true && item.push(next));
      return item;
    }, []);
    console.log('res', res); // [ { "value": "111", "name": "我是菜鸡1" } ,{ "value": "222", "name": "我是菜鸡2" } ,{ "value": "333", "name": "我是菜鸡3" } ,{ "value": "444", "name": "我是菜鸡4" } ]
    
  //需求1：求数组的和
    let arr = [1, 3, 5, 7];
    let sum = arr.reduce(function (pre, cur) {
      return pre + cur
    }, 0)
    console.log(sum); //16
    console.log(arr); //[1, 3, 5, 7]

  //需求2：查找两个数组的交集，返回这个交集的数组！
    let arr1 = [1, 3, 5, 7, 3, 6]
    let arr2 = [1, 3, 5, 8, 5, 3, 99, 33]
    let res = arr1.filter(function (items, i) {
      return (arr2.indexOf(items) !== -1)
    })
    console.log(res); //res这个数组有交集 数组的去重  [1, 3, 5, 3]
    let res1 = res.reduce(function (pre, cur) {
      return (pre.indexOf(cur) === -1) ? pre.concat(cur) : pre //满足pre这个数组的属性，有属于这个条件的时候，就返回到新数组内
    }, [])
    console.log(res1); //[1，3，5]

//给pre 赋值一个[]
    *  if (pre.indexOf(cur) === -1) {
       说明pre数组中不存在 cur 这个数据，需要把cur添加到 pre 数组中
       pre.push(cur)
       pre.concat(cur)
       return pre.concat(cur)
       } else {
          return pre
       } 
       return (pre.indexOf(cur) === -1) ? pre.push(cur) : pre 
       不能使用push push 的返回值是一个数组的长度 下一次的pre就是数组的长度 并不是一个数组

       pre.indexOf is not a function出现这个错误 
       indexOf这个方法名写错
       pre 没有这个方法

    //需求：求两个数的交集
    var arr1 = [1, 2, 2, 3, 4, 5];
    var arr2 = [2, 2, 3, 4, , 6, 7, 8];
    //第一步：遍历数组arr1，查询arr2之中是否含有arr1中的数组元素，若是有就把符合条件的元素放入新数组 ---使用filter方法
    var res = arr1.filter(function (item) {
      //就是那拿arr1中的每一个元素，来数组arr2中查询，若是存在的话，就是证明 arr2.indexOf(item) !== -1
      return (arr2.indexOf(item) !== -1)
    })
    // console.log(res); //输出的res为 [2, 2, 3, 4] --- 这个数组含有重复的元素，需要去重
    //第二步：数组的去重 使用reduce方法
    res = res.reduce(function (pre, cur) {
      //查询数组中是否含有该元素，若是没有的话，就拼接上去（不能push），若是有的话，就需要返回上一次循环的返回值（也就是pre)
      return (pre.indexOf(cur) === -1) ? pre.concat(cur) : pre
    }, [])
    console.log(res); // [2, 3, 4]


    var arr1 = [1, 2, 2, 3, 4, 5];
    var arr2 = [2, 2, 3, 4, , 6, 7, 8];
    //第一步：查找两个数组中的交集 --- 拿第一个数组的元素去第二个数组里面查找，若是有该元素，就返回到一个新的数组
    let res = arr1.filter(function (items) {
      return (arr2.indexOf(items) !== -1)
    })
    // console.log(res);
    //第二步：拿到有交集的数组，含有重复的数值，需要去重
    //查询数组本身是否含有该元素，若是没有就拼接这个元素到空数组，若是有就返回到原数组
    let res2 = res.reduce(function (pre, cur) {
      //先给pre赋值为一个数组
      return (pre.indexOf(cur) === -1) ? pre.concat(cur) : pre
    }, [])

    var arr1 = [1, 2, 2, 3, 4, 5];
    var arr2 = [2, 2, 3, 4, , 6, 7, 8];
    let res = arr1.filter(function (items) {
      return (arr2.indexOf(items) !== -1)
    }).reduce(function (pre, cur) {
      return (pre.indexOf(cur) === -1) ? pre.concat(cur) : pre
    }, [])
    console.log(res);