前端数组对象去重的几种方法，拿来即用

工作中有许多地方地方需要前端处理数据，总结了几种数据去重的方法都实验过，可以使用

  初始数据 id有相同的需要去重
  let person = [
         { id: 0, name: "小明" },
         { id: 1, name: "小张" },
         { id: 2, name: "小李" },
         { id: 3, name: "小孙" },
         { id: 1, name: "小周" },
         { id: 2, name: "小陈" },
      ];
 
      // 第一种使用去重reduce
      
      let obj = {};
      let peon = person.reduce((cur, next) => {
         obj[next.id] ? "" : obj[next.id] = true && cur.push(next);
         return cur;
      }, []) //设置cur默认类型为数组，并且初始值为空的数组
      console.log(peon);
      
      // 第二种种使用reduceRight去重
      //  reduceRight和 reduce() 功能是一样的，不同的是 reduceRight() 从数组的末尾向前将数组中的   数组项做累加。
      
      let hash = {};
      const newArr = person.reduceRight((item, next) => {
         hash[next.id] ? '' : hash[next.id] = true && item.push(next);
         return item
      }, []);
      console.log(newArr);
      
      // 第三种   for循环 利用对象访问属性的方法，判断对象中是否存在重复的key
      // 一
      var result = [];
      var obj = {};
      for (var i = 0; i < person.length; i++) {
         if (!obj[person[i].id]) {
            result.push(person[i]);
            obj[person[i].id] = true;
         }
      }
    
      for (var i = 0; i < person.length; i++) {
         for (var j = i + 1; j < person.length; j++) {
            if (person[i].id == person[j].id) {
               person.splice(j, 1);
            }
         }
      }
      console.log(person);
      
      // 第三种 封装成方法 使用for循环 利用对象访问属性的方法，判断对象中是否存在重复的key
      
      function deWeight(arr) {
         for (var i = 0; i < arr.length - 1; i++) {
            for (var j = i + 1; j < arr.length; j++) {
               if (arr[i].id == arr[j].id) { // id为需要去重字段
                  arr.splice(j, 1);
                  //因为数组长度减小1，所以直接 j++ 会漏掉一个元素，所以要 j--
                  j--;
               }
            }
         }
         return arr
      }
      console.log(deWeight(person))
      
      // 第四种 封装成方法 使用for循环 利用对象访问属性的方法，判断对象中是否存在重复的key
      // 保留原数据，获取去重后的新数组
      
      function distinct1(arr, key) {
         var newobj = {}, newArr = [];
         for (var i = 0; i < arr.length; i++) {
            var item = arr[i];
            if (!newobj[item[key]]) {
               newobj[item[key]] = newArr.push(item);
            }
         }
         return newArr;
      }
      console.log(distinct1(person, 'id'))
      
      // 第五种 和第四种差不多 保留原数据，获取去重后的新数组
      
      function distinct2(arr, key) {
         var newArr = [];
         for (var i = 0; i < arr.length; i++) {
            var flag = true;
            for (var j = 0; j < newArr.length; j++) {
               if (arr[i][key] == newArr[j][key]) {
                  flag = false;
                  break
               };
            };
            if (flag) {
               newArr.push(arr[i]);
            };
         };
         return newArr;
      }
      console.log(distinct2(person, 'id'))
	
	  // 第六种 会更改数组的原始数据
	  
      function distinct3(arr, key) {
         for (let i = 0; i < arr.length; i++) {
            for (let j = i + 1; j < arr.length; j++) {
               if (arr[i][key] === arr[j][key]) {
                  arr.splice(j, 1);
                  j = j - 1;
               }
            }
         }
         return arr;
      }
      console.log(distinct3(person, 'id'))