# 数组去重
```js
// 数组去重方法总结
// v1. 双层循环去重
function unique(arr) {
    let res = [];
    // 外层循环遍历原始数组
    for (var i = 0, arrLen = arr.length; i < arrLen; i++) {
        // 内层循环遍历res数组
        for (var j = 0, resLen = res.length; j < resLen; j++) {
            if (arr[i] === res[j]) {
                break;
            }
        }
        // 关键点：遍历完毕之后，如果arr[i]是唯一的，那么必定满足j===resLen
        if (j === resLen) {
            res.push(arr[i]);
        }
    }
    return res;
}
// 优点： 兼容性好


// v2. indexOf去重
function unique(arr) {
    var res = [];
    for (var i = 0, len = arr.length; i < len; i++) {
        var cur = arr[i];
        if (res.indexOf(cur) === -1) {
            res.push(cur);
        }
    }
    return res;
}
// 优点：使用indexOf可以简化内层循环


// v3. 先排序，然后去重
function unique(arr){
    var res = [];
    // 排序之后的数组
    var sortedArr = arr.concat().sort();
    // seen表示的是当前的比较项
    var seen;
    // v1
    /*for (var i = 0, len = sortedArr.length; i < len; i++) {
        // 从第一个元素开始，比较相邻的元素是否相同
        if (!i  || seen !== sortedArr[i]) {
            res.push(sortedArr[i]);
        }
        seen = sortedArr[i];
    }*/

    // v2
    for (var i = 0, len = sortedArr.length; i < len; i++) {
        // 最后一个和undefined比较
        if (sortedArr[i] !== sortedArr[i+1]) {
            res.push(sortedArr[i]);
        }
    }
    return res;

}

// v4. 封装一个unique的API【重点掌握】
function unique(arr, isSorted){
    var res = [];
    var seen = [];

    for (var i = 0, len = arr.length; i < len; i++) {
        var value = arr[i];
        // 根据是否排序选择去重方式
        if (isSorted) {
            // 这个排序方法要学会
            if (!i || seen !== value) {
                res.push(value);
            }
            seen = value;
        }
        else if (res.indexOf(value) === -1) {
            res.push(value);
        }
    }
    return res;
}

// TODO: 如何把字母的大小写视为一致，比如'a'和'A'，保留一个就可以了?
// v5: 去重API增强
/**
 * 去重API增强
 * @param arr 表示要去重的数组，必填
 * @param isSorted 表示函数传入的数组是否已排过序，如果为 true，将会采用更快的方法进行去重
 * @param iteratee 传入一个函数，可以对每个元素进行重新的计算，然后根据处理的结果进行去重
 * @return {Array}
 */
function unique(arr, isSorted, iteratee){
    var res = [];
    var seen = [];

    for (var i = 0, len = arr.length; i < len; i++) {
        var value = arr[i];
        // 处理iteratee参数
        var computed = iteratee ? iteratee(value, i, arr) : value;
        if (isSorted) {
            if (!i || seen !== value) {
                res.push(value);
            }
            // 更新为最新的computed数据(是经过iteratee这个函数处理之后的结果)
            seen = computed;
        }
        else if (iteratee) {
            // 处理iteratee的核心逻辑
            if (seen.indexOf(computed) === -1) {
                // seen里面放的是转换处理之后的数值
                seen.push(computed);
                // 结果里面放入的始终是数组的原始值，而不是经过转换之后的数值
                res.push(value);
            }
        } else if (res.indexOf(value) === -1) {
            // 常规去重方法
            res.push(value);
        }
    }
    return res;
}


// TODO: 使用filter函数简化外层循环？
// v6. filter简化去重逻辑
// 使用indexOf简化
function unique(arr){
    var res = arr.filter(function (item, index, self) {
        // indexOf实际上找到的是第一次出现的位置
        return self.indexOf(item) === index;
    });
    return res;
}

// 使用排序去重的方法
function unique(arr) {
    return arr.concat().sort().filter(function (item, index, self) {
        // 后面的一项和前面的项进行比较
        return !index || item !== self[index - 1];
    });
}


// v7. 使用Object键值对去重(推荐使用，可以去重所有的数据类型)
function unique(arr) {
    var obj = {};
    var res =  arr.filter(function (item) {
        // 问题1： 无法区分1和'1'
        // return obj.hasOwnProperty(item) ? false : (obj[item] = true);


        // 问题2: 无法区分{value: 1}和{value: 2}
        // { number1: true,
        //   stringa: true,
        //   stringA: true,
        //   number2: true,
        //   stringb: true,
        //   stringc: true,
        //   number3: true }
        // return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true);


        // 最终解决方案：使用JSON.stringfy, 先把对象序列化处理
        let temp = typeof item + JSON.stringify(item);
        return obj.hasOwnProperty(temp) ? false : (obj[temp] = true);
    });
    console.log('obj now:', obj)
    return res;
}


// v8: ES6去重大法
function unique(arr){
    return Array.from(new Set(arr));
}
// 代码简化1
function unique(arr){
    return [...new Set(arr)];
}
// 代码简化2
var unique = (a) => [...new Set(a)];

// 使用Map去重
function unique(arr){
    const seen = new Map();
    return arr.filter(a => !seen.has(a) && seen.set(a, 1));
}



console.log(unique([1, 2, 3, 2, '1']))
console.log(unique([1, '1', 2, 3], true))
console.log(unique([1, 1, 'a', 'A', 2, 'b', 'c', 3, '1', {value : 1}, {value: 2}, {value: 1}], false, function (item, index, arr) {
    return typeof item === 'string' ? item.toLowerCase() : item;
}))

var array = [1, 1, '1', '1', null, null, undefined, undefined, new String('1'), new String('1'), /a/, /a/, NaN, NaN];
console.log(unique(array));

```

【编程题与分析题】数组去重