数组去重

数组去重

1. es6

var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN, NaN, 'NaN', 0, 0, 'a', 'a', {}, {}];
// console.log(arr);

// 1 ES6
function unique1(arr){
  if(!Array.isArray(arr)){
    console.log('type error');
    return
  }
// new Set(arr) == Set { 1, 'true', true, 15, false, undefined, null, NaN, 'NaN', 0, 'a', {}, {} }
  // console.log(Array.from(new Set(arr))); //将一个对象转为数组
  return [...new Set(arr)]

}
// console.log(unique1(arr));
//[ 1, 'true', true, 15, false, undefined, null, NaN, 'NaN', 0, 'a', {}, {} ]
复制代码

2. indexOf()

//2. indexOf()
function unique2(arr){
  
  var res=[]
  arr.forEach((item,index)=>{
    if (arr.indexOf(item) == index) {
      res.push(item)
    }
  })
  return res
}
// console.log(unique2(arr)); //[ 1, 'true', true, 15, false, undefined, null, 'NaN', 0, 'a', {}, {} ]
// console.log({} === {}); //false ===比较两个值的时候先判断两个值的类型，如果不是同一类型，直接返回false，值类型相同再进行值的比较。
// indexOf()是一个判断严格相等的方法=== ，先判断类型，类型相同，再判断值（引用类型的值地址）是否相同
// if()里面是隐式类型转换
复制代码

3. sort与reduce()

// 3. sort与reduce()
function unique3(arr) {
  
  arr.sort((a, b) => a - b);//从小到大
  var res=[arr[0]];
  for(var i=1;i<arr.length;i++){
    if(arr[i]!==arr[i-1]){
      res.push(arr[i])
    }
  }
  return res
}
console.log(unique3(arr));
复制代码

4. includes与reduce()

// 4. includes与reduce()
function unique4(arr) {
  return arr.reduce((prev, cur) => prev.includes(cur) ? prev : [...prev, cur], []);

}
// console.log(unique4(arr));
复制代码

5. 利用Map()去重

//5 利用Map()去重
function unique5(arr) {
  if (!Array.isArray(arr)) {
    console.log('type error');
    return
  }
  let map =new Map();
  let res=[];
  for(let i=0,l=arr.length;i<l;i++){
    if(map.has(arr[i])){
      map.set(arr[i], true); //被重复了该key值
    }else{
      map.set(arr[i], false); //没有重复该key值
      res.push(arr[i])
    }
  }
  console.log(map); //Map { 2 => true, 3 => true, 4 => false, 5 => false }
  return res
}
// console.log(unique5([2,3,4,5,2,3]));
复制代码

6. 利用for嵌套for，然后splice去重（ES5中最常用

function unique6(arr){
  for(var i=0;i<arr.length;i++){
    for (var j = i+1; j < arr.length; j++){
      if(arr[i]==arr[j]){
        arr.splice(j,1);
        j--;
      }
    }
  }
  return arr
}
复制代码

7. 利用indexOf()去重

// 7. 利用indexOf()去重
function unique7(arr) {
  var res=[];
  arr.forEach((item)=>{
    if(res.indexOf(item)<0){
      res.push(item)
    }
  })
  return res
}
复制代码

8. filter()

function unique8(arr) {
  var res ;
  res = arr.filter((item,i) => {
    return arr.indexOf(item)==i
  })
  return res
}
复制代码

9. map()扩展 计算两数之和

// 计算两数之和
/**给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1] */
function sum(arr,target){
  let map = new Map();
  for (let i = 0, l = arr.length; i < l; i++) {
    //  map.set(arr[i], i);
    // if(map.has(target-arr[i])){
    //   // index = arr.indexOf(target - arr[i])
    //   return [map.get(arr[i]), map.get(arr[target - arr[i]])]
    // }
    if(map.has(arr[i])){
      return [map.get(arr[i]),i]
    }else{
      map.set(target - arr[i],i)
    }
  }
}
复制代码

转载于:https://juejin.im/post/5ce2369851882579da4bef98