前言

数组去重           ，可以说是一个比较常见的面试题
 
  
 
  
 
  
 
  
 
  
 ，今天来盘点一下都有哪些方法可以实现数组去重           。

方法1 
  
  
  
  
  、双重for循环

这是一个最笨的方法










，双重循环
 
  
 
  
 
  
 
  
 
  
 。

var arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1] // 数组去重： // 方法1： 双重for 循环 function newArrFn (arr) { // 创建一个新的空数组 let newArr = [] for(let i = 0;i<arr.length;i++){ // 设置一个开关  
  
  
  
  
 ，如果是true 
  
  
  
  
  ，就存进去


 


 


 


 


 

，不是就不存 let flag = true for(let j = 0;j<newArr.length;j++){ // 原数组和新数组作比较 
 
 
 
 
，如果一致  
   
   
   
   
   ，开关变为 false arr[i] === newArr[j] ? flag = false : flag }; flag ? newArr.push(arr[i]) : newArr }; return newArr } console.log(newArrFn(arr));

方法2 
  
  
  
  
  
、for循环 +findIndex

主要利用findIndex 的特性

 

 

 

 

 
，查找元素找不到就返回-1
 

 

 

 

 

， 接下来就需要判断           ，如果是-1
 

 
 

 
 

 
 

 
 

 
 ，说明没找到










，就往新数组里面添加元素










。

var arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1] // 数组去重： // 方法2： for + indexof function newArrFn (arr) { let newArr = [] for(let i = 0;i<arr.length;i++){ newArr.indexOf(arr[i]) === -1 ? newArr.push(arr[i]) : newArr }; return newArr } console.log(newArrFn(arr));

方法3

 


 


 


 


 

、sort 排序

首先利用 sort 方法进行排序  
  
  
  
  
 。进行循环                ，如果原数组的第 i 项和新数组的i - 1 项不一致
 
 
 
 
 
 
 
 
 
 
 ，就push进去 
  
  
  
  
  。

var arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1] // 数组去重： // 方法3： for + sort function newArrFn (arr) { arr = arr.sort() let newArr = [] for(let i = 0;i<arr.length;i++){ arr[i] === arr[i-1] ? newArr : newArr.push(arr[i]) }; return newArr } console.log(newArrFn(arr));

方法4 
 
 
 
 
 、Set

ES6中新增了数据类型Set















，Set的一个最大的特点就是数据不重复


 


 


 


 


 

。Set函数可以接受一个数组（或类数组对象）作为参数来初始化           ，利用该特性也能做到给数组去重 
 
 
 
 
。

var arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1] // 数组去重： // 方法4： set function newArrFn (arr) { // .new Set方法
 
  
 
  
 
  
 
  
 
  
 ，返回是一个类数组










，需要结合 ...运算符  
  
  
  
  
 ，转成真实数组 return ([...new Set(arr)]) } console.log(newArrFn(arr));

方法5 
   
   
   
   
   
、set + Array.from

利用 set数据不重复的特点 
  
  
  
  
  ，结合 Array.from

var arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1] // 数组去重： // 方法5： set + Array.from function newArrFn (arr) { // .new Set方法


 


 


 


 


 

，返回是一个类数组 
 
 
 
 
，需要结合 Array.from  
   
   
   
   
   ，转成真实数组 return (Array.from(new Set(arr)) ) } console.log(newArrFn(arr));

方法6
 

 

 

 

 
、filter + indexOf

indexOf

 

 

 

 

 
，可以检测某一个元素在数组中出现的位置
 

 

 

 

 

，找到返回该元素的下标           ，没找到返回 -1

var arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1] // 数组去重： // 方法6 ：filter + findIndex function newArrFn (arr) { // 利用indexOf检测元素在数组中第一次出现的位置是否和元素现在的位置相等
 

 
 

 
 

 
 

 
 

 
 ， // 如果相等










，说明数组中没有重复的 return Array.prototype.filter.call(arr, function (item, index) { return arr.indexOf(item) === index }) } console.log(newArrFn(arr));

方法7
 

 

 

 

 

 、includes

利用 includes 检查新数组是否包含原数组的每一项  
   
   
   
   
   。 如果不包含                ，就push进去

var arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1] // 数组去重： // 方法7 ：for + includes function newArrFn (arr) { // 利用includes 检查新数组是否包含原数组的每一项 // 如果不包含
 
 
 
 
 
 
 
 
 
 
 ，就push进去 let newArr = [] for(let i = 0;i<arr.length;i++){ newArr.includes(arr[i]) ? newArr: newArr.push(arr[i]) }; return newArr } console.log(newArrFn(arr));

方法 8          、 for + object

利用对象属性名不能重复这一特点

 

 

 

 

 
。如果对象中不存在















，就可以给 push 进去

var arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1] // 数组去重： // 方法8 ：for + obj function newArrFn (arr) { // 利用对象属性名不能重复这一特点 // 如果对象中不存在           ，就可以给 push 进去 let newArr = [] let obj = {} for(let i = 0;i<arr.length;i++){ if (!obj[arr[i]]) { newArr.push(arr[i]) obj[arr[i]] = 1 } else { obj[arr[i]] ++ } }; return newArr } console.log(newArrFn(arr));

方法9 

 
 

 
 

 
 

 
 

 
 
、for + splice

利用 splice 进行切割

var arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1] // 数组去重： // 方法8 ：for + splice // 利用 splice 进行切割
 

 

 

 

 

。 function newArrFn (arr) { for(let i = 0; i<arr.length; i++){ for(let j = i + 1; j<arr.length; j++){ if (arr[i] === arr[j]) { arr.splice(j,1); j-- } }; } return arr } console.log(newArrFn(arr));

方法10










、filter + indexOf

利用 filter 过滤 配合 indexOf 查找元素

var arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1] // 数组去重： // 方法10 ：filter + indexOf // filter 过滤 配合 indexOf 查找元素 function newArrFn (arr) { return arr.filter((item, index) => { return arr.indexOf(item) === index }) } console.log(newArrFn(arr));

方法11                、Map

利用数据结构存值的特点

var arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1] // 数组去重： // 方法11 ：Map function newArrFn (arr) { let newArr = [] let map = new Map() for(let i = 0;i<arr.length;i++){ // 如果 map里面不包含
 
  
 
  
 
  
 
  
 
  
 ，就设置进去 if (!map.has(arr[i])) { map.set(arr[i], true) newArr.push(arr[i]) } }; return newArr } console.log(newArrFn(arr));

方法12：reduce

var arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1] // 数组去重： // 方法12 ：reduce function newArrFn (arr) { let newArr = [] return arr.reduce((prev, next,index, arr) => { // 如果包含










，就返回原数据  
  
  
  
  
 ，不包含 
  
  
  
  
  ，就把新数据追加进去 return newArr.includes(next) ? newArr : newArr.push(next) }, 0) } console.log(newArrFn(arr));