通常在面试过程中会碰到数组而加重，有时需要手写数组来加重方法的代码。 如果被提问，加重数组的方法是什么？ 如果你能回答其中的十种，面试官对你的好感和评价会大大提高。 实际项目中遇到的数组的重量通常交给后端处理，很少让前端处理数组的重量。 但是，作为知识的储备，应该掌握常用的方法和想法。
一、利用ES6 Set去重（ES6中最常用）
不考虑兼容性，去除这种重量的方法代码最少。 但是，该方法无法删除“{}”的空对象，后续的高级方法将添加删除重复“{}”的方法。函数unique {
returnArray.from(newset(arr ) )
}
vararr=[ 1，1，' true '，' true '，true，15，15，false，false，undefined，null，null，NaN，NaN
控制台. log (unique (arr ) )
//[1，' true '，true，15，false，undefined，null，NaN，' NaN '，0，' a '，{}，{}]
二、利用for嵌套for，然后splice去重（ES5中最常用）
双循环，外层循环元素，内层循环函数unique {
for(varI=0； iarr.length； I ) {
for(varj=I1； jarr.length； j ) {
if(arr[I]==arr[j] ) {
//第一个相当于第二个，拼接方法删除第二个
ARR.splice(j，1；
j----；
}
}
}
返回警报；
if (！ array.isarray(arr ) ) }
console.log('typeerror！' ）
返回
}
var array=[]；
for(varI=0； i arr.length； I ) {
if(array.indexof(arr[I] )===-1 ) {
(array.push(arr[I] ) ) ) ) ) ) )。
}
}
返回阵列；
}
vararr=[ 1，1，' true '，' true '，true，15，15，false，false，undefined，null，null，NaN，NaN
控制台. log (unique (arr ) )
//[1，' true '，15，false，undefined，NaN，NaN，' NaN '，' a '，{…}]
//NaN和{}不会变重，两个null保持不变，在
三、利用indexOf去重
中创建新的空结果数组。 对原始数组进行for循环，以确定结果数组中是否存在当前元素，如果有相同的值则跳过，否则推送进入数组。函数unique {
if (！ array.isarray(arr ) ) }
console.log('typeerror！' ）
返回
}
var array=[]；
for(varI=0； i arr.length； I ) {
if(array.indexof(arr[I] )===-1 ) {
(array.push(arr[I] ) ) ) ) ) ) )。
}
}
返回阵列；
if (！ array.isarray(arr ) ) }
console.log('typeerror！' ）
返回
}
var array=[]；
for(varI=0； i arr.length； I ) {
if(array.indexof(arr[I] )===-1 ) {
(array.push(arr[I] ) ) ) ) ) ) )。
}
}
返回阵列；
}
vararr=[ 1，1，' true '，' true '，true，true，true，1]
5,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}]; console.log(unique(arr)) // [1, "true", true, 15, false, undefined, null, NaN, NaN, "NaN", 0, "a", {…}, {…}] //NaN、{}没有去重四、利用sort()
利用sort()排序方法，然后根据排序后的结果进行遍历及相邻元素比对。
function unique(arr) { if (!Array.isArray(arr)) { console.log('type error!') return; } arr = arr.sort() var arrry= [arr[0]]; for (var i = 1; i < arr.length; i++) { if (arr[i] !== arr[i-1]) { arrry.push(arr[i]); } } return arrry; } 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(unique(arr)) // [0, 1, 15, "NaN", NaN, NaN, {…}, {…}, "a", false, null, true, "true", undefined] //NaN、{}没有去重五、利用对象的属性不能相同的特点进行去重（这种数组去重的方法有问题，不建议用，有待改进）
function unique(arr) { if (!Array.isArray(arr)) { console.log('type error!') return } var arrry= []; var obj = {}; for (var i = 0; i < arr.length; i++) { if (!obj[arr[i]]) { arrry.push(arr[i]) obj[arr[i]] = 1 } else { obj[arr[i]]++ } } return arrry; } 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(unique(arr)) //[1, "true", 15, false, undefined, null, NaN, 0, "a", {…}] //两个true直接去掉了，NaN和{}去重六、利用includes
function unique(arr) { if (!Array.isArray(arr)) { console.log('type error!') return } var array =[]; for(var i = 0; i < arr.length; i++) { if( !array.includes( arr[i]) ) {//includes 检测数组是否有某个值 array.push(arr[i]); } } return array } 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(unique(arr)) //[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}, {…}] //{}没有去重七、利用hasOwnProperty
利用hasOwnProperty 判断是否存在对象属性
function unique(arr) { var obj = {}; return arr.filter(function(item, index, arr){ return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true) }) } 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(unique(arr)) //[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}] //所有的都去重了八、利用filter
function unique(arr) { return arr.filter(function(item, index, arr) { //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素 return arr.indexOf(item, 0) === index; }); } 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(unique(arr)) //[1, "true", true, 15, false, undefined, null, "NaN", 0, "a", {…}, {…}]九、利用递归去重
function unique(arr) { var array= arr; var len = array.length; array.sort(function(a,b){ //排序后更加方便去重 return a - b; }) function loop(index){ if(index >= 1){ if(array[index] === array[index-1]){ array.splice(index,1); } loop(index - 1); //递归loop，然后数组去重 } } loop(len-1); return array; } 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(unique(arr)) //[1, "a", "true", true, 15, false, 1, {…}, null, NaN, NaN, "NaN", 0, "a", {…}, undefined]十、利用Map数据结构去重
创建一个空Map数据结构，遍历需要去重的数组，把数组的每一个元素作为key存到Map中。由于Map中不会出现相同的key值，所以最终得到的就是去重后的结果。
function arrayNonRepeatfy(arr) { let map = new Map(); let array = new Array(); // 数组用于返回结果 for (let i = 0; i < arr.length; i++) { if(map .has(arr[i])) { // 如果有该key值 map .set(arr[i], true); } else { map .set(arr[i], false); // 如果没有该key值 array .push(arr[i]); } } return array ; } 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(unique(arr)) //[1, "a", "true", true, 15, false, 1, {…}, null, NaN, NaN, "NaN", 0, "a", {…}, undefined]十一、利用reduce+includes
function unique(arr){ return arr.reduce((prev,cur) => prev.includes(cur) ? prev : [...prev,cur],[]); } 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(unique(arr)); // [1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}, {…}]十二、[...new Set(arr)]
[...new Set(arr)] //代码就是这么少----（其实，严格来说并不算是一种，相对于第一种方法来说只是简化了代码）十三、总结
这12种无非就两类：
1、两层循环法
2、利用语法自身键不可重复性其他的都是用了语言不通的api,算不上单独的一种方法，比如indexOf 和includes 两层循环都是同一类
以上方法有些不是很完美，可能只适合部分场景，用的时候需谨慎，还是应该以理解思路为主。