数组去重（算法）

方法一：哈希表思想

思路：新建一个结果数组、一个存储标志的对象，遍历数组，对象中arr[i]对应的值为ture的时候不重复添加

for…of循环的i代表的是value（多用于数组），for…in循环的是key（多用于对象）；

function unique(arr) {
    var result = [];
    var hash = {};
    for (let elem of arr) { 
        if (!hash[elem]) {
            result.push(elem);
            hash[elem] = true; //作为一个是否在数组中存在的标志
        }
    }
    return result;
}
var arr = [1, 23, 34, 45, 1, 6, 4, 23];
unique(arr);//[1, 23, 34, 45, 6, 4]

方法二：遍历数组，用indexOf() / includes()

思路1 - indexOf：新建一个数组 result，遍历原数组，当arr[i]不存在于新数组中，就添加 push 进新数组，得到的新数组就是不重复的。

function unique(arr){
    let res = [];
    for(let item of arr) {
        if(res.indexOf(item) === -1) {
            res.push(item);
        }
    }
    return res
}
var arr = [1, 23, 34, 45, 1, 6, 4, 23];
unique(arr);//[1, 23, 34, 45, 6, 4]

思路2 - includes：新建一个数组result，如果新数组中该值i不存在，则将原数组内容添加push(i)。

for…of循环的i代表的是value（多用于数组），for…in循环的是key（多用于对象）；

function unique(arr) {
    let result = [];
    for(let item of arr) {
        if(!res.includes(item)) {
            res.push(item);
        }
    }
    return result;
}
var arr = [1, 23, 34, 45, 1, 6, 4, 23];
unique(arr);//[1, 23, 34, 45, 6, 4]

方法三：数组下标判断法

思路1：利用 indexOf 返回的始终是第一个相同数值的下标，如果新增的内容在原来数组中的下标和现在的下标不同，那么就证明它是重复的

function unique(arr){
    var result=[];
    for (var i = 0; i < arr.length; i++) {
        if(arr.indexOf(arr[i]) === i){ //下标不同，代表了重复
            result.push(arr[i]);
        }
    }
    return result;
}
var arr = [1, 23, 34, 45, 1, 6, 4, 23];
unique(arr);//[1, 23, 34, 45, 6, 4]

思路2（重复的直接删除，不保留）：利用indexOf和lastIndexOf，从前往后和从后往前找到的下标如果相同，就证明没有重复的值；

function unique(arr){
    var result=[];
    for (var i = 0; i < arr.length; i++) {
        if(arr.indexOf(arr[i]) === arr.lastIndexOf(arr[i])){
            result.push(arr[i]);
        }
    }
    return result;
}
var arr = [1, 23, 34, 45, 1, 6, 4, 23];
unique(arr);//[34, 45, 6, 4]

方法四：排序，去除相邻的重复值

思路：给数组排序，排序后相同的值会相邻，遍历排序后的数组时，新数组只加入不与前一值重复的值。

function unique(arr){
    arr.sort();
    var result=[arr[0]];
    for (var i = 1; i < arr.length; i++) {
        if(arr[i] !== result[result.length-1]){
            result.push(arr[i]);
        }
    }
    return result;
}
var arr = [1, 23, 34, 45, 1, 6, 4, 23];
unique(arr);//[1, 23, 34, 4, 45, 6]

新方法：使用reduce

let arr = [1, 23, 34, 45, 1, 6, 4, 23];;
let result = arr.sort().reduce((init, current) => {
    if(init.length === 0 || init[init.length-1] !== current) {
        init.push(current);
    }
    // 这里的if也可以使用indexOf方法进行判断是否等于-1
    return init;
}, []);
console.log(result); // [1, 23, 34, 4, 45, 6]

方法五：双层循环遍历

思路1：有重复值时终止当前循环i，进入外层循环i+1；找到的是往后遍历不会有重复值的值；

function unique(arr){
    var result=[];
    for (var i = 0; i < arr.length; i++) {
        for (var j = i+1; j < arr.length; j++) {
            if(arr[i]===arr[j]){
                ++i;
            }
        }
        result.push(arr[i]);
    }
    return result;
}
var arr = [1, 23, 34, 45, 1, 6, 4, 23];
unique(arr);//[34, 45, 1, 6, 4, 23]注意这里的顺序和上面的都不同

思路2：两层循环遍历，如果有重复的值，则用splice（）删除

function unique(arr) {
    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
}
var arr = [1, 23, 34, 45, 1, 6, 4, 23];
unique(arr);//[1, 23, 34, 45, 6, 4]

方法六：ES6的Set结构（高性能）

思路：Set结构成员的值都是唯一的，Set函数可以接受一个数组作为参数，用来初始化。

function unique(arr){
    var x = new Set(arr);
    return [...x]; // 这里直接返回x的话，结果是Set(6){1, 23, 34, 45, 6, 4}
}
// 或者简写成
function unique(arr){
    return [...new Set(arr)]
}
var arr = [1, 23, 34, 45, 1, 6, 4, 23];
unique(arr);//[1, 23, 34, 45, 6, 4]
// 去除数组的重复成员
[...new Set(array)]
//上面的方法也可以用于，去除字符串里面的重复字符。
[...new Set('ababbc')].join('')
// "abc"

方法七：ES6的 Array.filter()

思路：利用Array.filter()方法的过滤方法，将数组进行过滤，筛选条件是数组下标与检索下标一致。

concat() 方法用于连接两个或多个数组；该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

filter()方法通过检查指定数组中符合条件的所有元素；不会改变原始数组，创建一个新的数组。

function unique(arr) {
    return arr.filter((item, index)=> {
        return arr.indexOf(item) === index
    })
}
var arr = [1, 23, 34, 45, 1, 6, 4, 23];
unique(arr);//[1, 23, 34, 45**加粗样式**, 6, 4]