数组去重（JavaScript）先从网上整理一波，待验证

数组去重（JavaScript）

前端面试题：给定一个数组[1,3,2,4,5,3,22,21,2],去重。
方法很多

• for循环遍历
  
  • 双层for循环，存储到新的数组
  • 双层for循环，不声明新的数组，在原数组使用splice方法
• 利用对象的属性唯一（有问题）
• 先排序，然后将第n+1个与第n个比较去重
• ES6语法，set()
• 使用递归
• 神操作
• 一些轮子
• 其他，比如包含了字符串，或者数组很大

---

for循环遍历

Array.prototype.distinct = function(){
 var arr = this,
  result = [],
  i,
  j,
  len = arr.length;
 for(i = 0; i < len; i++){
  for(j = i + 1; j < len; j++){
   if(arr[i] === arr[j]){
    j = ++i;
   }
  }
  result.push(arr[i]);
 }
 return result;
}
var arra = [1,2,3,4,4,1,1,2,1,1,1];
arra.distinct();    //返回[3,4,2,1]

Array.prototype.distinct = function (){
 var arr = this,
  i,
  j,
  len = arr.length;
 for(i = 0; i < len; i++){
  for(j = i + 1; j < len; j++){
   if(arr[i] == arr[j]){
    arr.splice(j,1);
    len--;
    j--;
   }
  }
 }
 return arr;
};
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];
var b = a.distinct();
console.log(b.toString()); //1,2,3,4,5,6,56

地址

利用对象的属性唯一（有问题）

function unique(arr){

　　var res =[];

　　var json = {};

　　for(var i=0;i<arr.length;i++){

　　　　if(!json[arr[i]]){

　　　　　　res.push(arr[i]);

　　　　　　json[arr[i]] = 1;

　　　　}

　　}

　　return res;

}

地址

先排序，然后将第n+1个与第n个比较去重

function unique(arr){

　　var arr2 = arr.sort();

　　var res = [arr2[0]];

　　for(var i=1;i<arr2.length;i++){

　　　　if(arr2[i] !== res[res.length-1]){

　　　　　　res.push(arr2[i]);

　　　　}

　　}

　　return res;

}

地址

ES6语法，set()

贴一个来自尤雨溪的,网址

// ES6
function unique (arr) {
  const seen = new Map()
  return arr.filter((a) => !seen.has(a) && seen.set(a, 1))
}
// or
function unique (arr) {
  return Array.from(new Set(arr))
}

作者：尤雨溪
链接：https://www.zhihu.com/question/29558082/answer/44854426
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

另一个简洁的

// ES6:一行关键代码
const uniqueItems = arr => [...new Set(arr)];

// 测试
let arr = [4, 5, 4, 6, 3, 4, 5, 2, 23, 1, 4, 4, 4, 1, 2, 3, 45];
const uniqueItems = arr => [...new Set(arr)];
uniqueItems(arr);

作者：庄引
链接：https://www.zhihu.com/question/29558082/answer/240560893
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

function uniteUnique() {
  const list=[].concat(...arguments);
  return list.reduce((oldlist,nowitem)=>oldlist.includes(nowitem)?oldlist:[...oldlist,nowitem],[]);
}

作者：知乎用户
链接：https://www.zhihu.com/question/29558082/answer/237161293
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

神操作

1. 如果使用underscore 或者 lodash的话应该可以使用_.uniq
2. ES6的实现，网址

// 去除相邻相同的元素
let nub1By = fn => ([x,y,...xs]) => y === undefined ? (x===undefined?[]:[x])
  : fn(x,y) ? nub1By(fn)([y,...xs])
  : [x,...nub1By(fn)([y,...xs])]

nub1By((a,b)=>a==b)([1,2,2,1,9,9,0])

// 数组去重——去除前面
let uniqBy = fn => ([x,...xs]) => x === undefined ? []
  : xs.filter(a=>fn(a,x)).length !== 0 ? uniqBy(fn)(xs)
  : [x,...uniqBy(fn)(xs)]

uniqBy((a,b)=>a==b)([1,2,2,1,9,9,0])

// 数组去重——去除后面
let uniq1By = fn => arr => uniqBy(fn)(arr.reverse()).reverse()

uniq1By((a,b)=>a==b)([1,2,2,1,9,9,0])

一些轮子

jQuery: $.unique
underscore: _.unique