简单去重比较/复杂数据去重处理

简单去重比较

准备测试代码：

const arr1 = Array.from (new Array (100000), (item, index) => {
  return index;
});
const arr2 = Array.from (new Array (50000), (item, index) => {
  return index * 2;
});
console.log ('开始测试');
const start = new Date().getTime();
distinct(arr1, arr2); // 去重方法
const end = new Date ().getTime ();
console.log ('测试结束');
console.log ('测试时间' + (end - start) / 1000 + 's');

一：filter + indexOf

function distinct(arr1, arr2) {
  console.log('filter + indexOf');
  const arr = [...arr1, ...arr2];
  return arr.filter((item, index) => {
    return arr.indexOf(item) === index;
  });
}

效果：时间11s

二：双重循环，删除(splice)重复项

function distinct(a, b) {

　　console.log('双重for循环');

  const arr = a.concat(b);
  for (let i = 0, len = arr.length; i < len; i++) {
    for (let j = i + 1; j < len; j++) {
      if (arr[i] == arr[j]) {
        arr.splice(j, 1);
        // splice 会改变数组长度，所以要将数组长度 len 和下标 j 减一
        len--;
        j--;
      }
    }
  }
  return arr
}

效果：22s

 三、includes + push

function distinct(arr1, arr2) {
  console.log('includes + push新数组');
  const arr = [...arr1, ...arr2];
  const result = [];
  for (item of arr) {
    !result.includes(item) && result.push(item);
  }
  return result;
}

效果：11s

 

四、先排序(sort),然后比较临近2个

function distinct(arr1, arr2) {
  console.log('先排序, 比较临近的2个 然后push');
  let arr = [...arr1, ...arr2];
  arr = arr.sort((a, b) => {return a - b});
  const result = [];
  for (let i = 0, len = arr.length; i < len; i++) {
    (arr[i] !== arr[i + 1]) && result.push(arr[i]);
  }
  return result;
}

效果：0.03s

四、使用set

function distinct(arr1, arr2) {
  console.log('使用set');
  const arr = [...arr1, ...arr2];
  return Array.from(new Set(arr));
}

效果：0.04s

五、 for循环配合对象使用，然后push， 优缺点，obj中不区分数据类型，导致number和string 值相同会被过滤掉

function distinct(arr1, arr2) {
  console.log('for循环配合对象使用，然后push');
  // const arr = [...arr1, ...arr2];
  // const arr = [1, 2, 3, '1', 2, '3'];
  const len = arr.length;
  const obj = {};
  const result = [];
  for (let i of arr) {
    if (!obj[i]) {
      result.push(i);
      obj[i] = 1
    }
  }
  // for (let i = 0; i < len; i++){
  //   if (!obj[arr[i]]) {
  //     console.log(obj[i]);
  //     result.push(arr[i]);
  //     obj[arr[i]] = 1;
  //   }
  // }return result;
}

效果：0.03s

六、reduce

function distinct(arr1, arr2) {
  console.log('reduce');
  const arr = [...arr1, ...arr2];
  arr.reduce((prev, cur) => {
    if (!prev.includes(cur)) {
      return [...prev, cur];
    } else {
      return prev;
    }
  }, []);
}

效果：110s

 数据复杂的去重

准备数据代码

console.log ('开始测试');
const start = new Date().getTime();
const arr = [
  {
    name: '禹丹丹',
    age: 18,
    stuId: '001',
    family: [
      {
        brother: '1',
        bage: 12,
      },
      {
        mother: '2',
        mage: 20,
      },
      {
        father: '3',
        fage: 10,
      },
    ],
  },
  {
    name: '江西元',
    age: 18,
    stuId: '002'
  },
  {
    name: '韩力明',
    age: 18,
    stuId: '003'
  },
  {
    name: '禹丹丹',
    age: 18,
    stuId: '002'
  },
  {
    name: '禹丹丹',
    age: 18,
    stuId: '001'
  },
];
distinct(arr);
const end = new Date().getTime();
console.log('测试结束');
console.log('测试时间' + (end - start) / 1000 + 's');

一、双重 for循环

function distinct(arr) {
  console.log('双重for循环');
  for (let i = 0, len = arr.length; i < len; i++) {
    for (let j = i + 1; j < len; j++) {
      if (arr[i].stuId === arr[j].stuId) {
        arr.splice(j, 1);
        // splice 会改变数组长度，所以要将数组长度 len 和下标 j 减一
        len--;
        j--;
      }
    }
  }
  console.log(arr);
  return arr
}

 二、for of 配合obj

function distinct(arr) {
  const result = [];
  const obj = {};
  for (item of arr) {
    if (!obj[item.stuId]) {
      result.push(item);
      obj[item.stuId] = true;
    }
  }
  console.log(result);
  return result;
}

 三、reduce+obj  和方式二类似

function distinct(arr) {
  const obj = {}; // 标识是否存在重复flag
  const newArr = arr.reduce((prev, cur) => {
    if (!obj[cur.stuId]) {
      obj[cur.stuId] = true;
      return [...prev, cur];
    }
    return prev;
  }, []);
  console.log(newArr);
  return newArr;
}