双层循环

const array = [1, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6];
function unique(array) {
    var res = [];
    for (var i = 0, arrayLen = array.length; i < arrayLen; i++) {
        for (var j = 0, resLen = res.length; j < resLen; j++) {
            if (array[i] === res[j]) {
                break;
            }
        }
        // 如何元素是唯一的话，内层循环的 j 变量等于 res 的长度。
        if (j === resLen) {
            res.push(array[i]);
        }
    }
    return res;
}
console.log(unique(array)); // [ 1, 2, 3, 4, 5, 6 ]

res 数组与 array 进行循环比较，如何元素没有重复的话，内层循环的变量 j 会等于 res 的长度。

那有没有办法简化循环了？有的可以利用 indexOf 函数。

const array = [1, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6];
function unique1(array) {
    var res = [];
    for (var i = 0, arrayLen = array.length; i < arrayLen; i++) {
        var current = array[i];
    // 如何元素是唯一的话，返回 -1。
        if (res.indexOf(current) === -1) {
            res.push(current);
        }
    }
    return res;
}
console.log(unique(array)); // [ 1, 2, 3, 4, 5, 6 ]

排序后去重

如何是已经排序好的数组对它去重很容易联想到对比前一个元素和后后一个元素，如果相同的话就是重复，不相同的话就是不重复。

在效率方面排序后去重肯定比双层循环效率高。

const array = [1, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6];
function unique2(array) {
    var res = [];
  // concat 函数放回原数组的浅拷贝，不改变原数组。
    var sortedArray = array.concat().sort();
    var seen;
    for (var i = 0, len = array.length; i < len; i++) {
        if (!i || seen !== sortedArray[i]) {
            res.push(sortedArray[i]);
        }
        seen = sortedArray[i];
    }
    return res;
}
console.log(unique(array)); // [ 1, 2, 3, 4, 5, 6 ]

整合成一个去重函数

根据上面的两种方法，我们可以写一个复合函数。这个函数有两个参数：array（去重数组）、isSorted（是否已排序）。

var array = [1, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6];
function unique(array, isSorted) {
    var res = [],
        seen;
    for (var i = 0, arrayLen = array.length; i < arrayLen; i++) {
        if (isSorted) {
            if (!i || seen !== array[i]) {
                res.push(array[i]);
            }
            seen = array[i];
        } else {
            if (res.indexOf(array[i]) === -1) {
                res.push(array[i]);
            }
        }
    }
    return res;
}
console.log(unique(array, true)); // [ 1, 2, 3, 4, 5, 6 ]

添加一个新需求

规定 ‘a’ 和 ‘A’ 是同一个元素，但上面的方法是过滤不了这种情况的。怎么办了？能不能在执行判断之前将元素转换成小写了，照着这个思路很容易想到，对每个元素判断之前执行一个自定义的函数，在现在这种情况这个自定义函数就是可以将元素转换为小写。

改进上面的代码

var array = [1, 1, 'a', 'A', 2, 2];
function unique(array, isSorted, iteratee) {
    var res = [];
    var seen = [];
    for (var i = 0, len = array.length; i < len; i++) {
        var value = array[i];
        var computed = iteratee ? iteratee(value, i, array) : value;
        if (isSorted) {
            if (!i || seen !== computed) {
                res.push(value);
            }
            seen = computed;
        } else if (iteratee) {
            // 为什么这里不用 array 来判断，其实这样做是没有意义的，因为 array 都是没有转换过的元素。
            if (seen.indexOf(computed) === -1) {
                seen.push(computed);
                res.push(value);
            }
        } else if (res.indexOf(value) === -1) {
            res.push(value);
        }
    }
    return res;
}
console.log(
    unique(array, false, function(item) {
        return typeof item == 'string' ? item.toLowerCase() : item;
    })
); // [ 1, 'a', 2 ]

filter 方法

可以用 filter 方法，简化外层循环。

indexOf

var array = [1, 1, 1, '1', 'a', 'A', 'a'];
function unique(array, iteratee) {
    const seen = [];
    var res = array.filter(function(item, index, array) {
        var computed = iteratee ? iteratee(item, index, array) : item;
        seen.push(computed);
        return seen.indexOf(item) === index;
    });
    return res;
}
console.log(
    unique(array, function(item, index, array) {
        return typeof item === 'string' ? item.toLowerCase() : item;
    })
); // [1, '1', 'a']

排序

var array = [1, 1, 1, '1', 'a', 'A', 'a'];
function unique(array, iteratee) {
    return array
        .concat()
        .sort()
        .filter(function(item, index, array) {
            const after = iteratee ? iteratee(item, index, array) : item;
            const before = iteratee ? iteratee(array[index - 1], index, array) : array[index - 1];
            return !index || after !== before;
        });
}
console.log(
    unique(array, function(item, index, array) {
        return typeof item === 'string' ? item.toLowerCase() : item;
    })
); // [ 1, '1', 'A' ]

object 键值对

利用 hasOwnProperty 方法。

var array = [1, 2, 1, 1, '1'];
function unique(array) {
    var obj = {};
    return array.filter(function(item, index, array){
          // !! 将赋值表达式的副作用转为 boolean
        return obj.hasOwnProperty(item) ? false : !!(obj[item] = true)
    })
}
console.log(unique(array)); // [1, 2]

这种方法分辨不 1 和 ‘1’ 的区别，这是因为 object 的键名都是字符串。

改进一下：用 typeof item + item 作为 key。

var array = [1, 2, 1, 1, '1'];
function unique(array) {
    var obj = {};
    return array.filter(function(item, index, array){
        return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
    })
}
console.log(unique(array)); // [1, 2, "1"]

但是改进后还是分辨了不了对象元素，再改进：用 JSON.stringify 序列化一下。

var array = [{value: 1}, {value: 1}, {value: 2}];
function unique(array) {
    var obj = {};
    return array.filter(function(item, index, array){
        console.log(typeof item + JSON.stringify(item))
        return obj.hasOwnProperty(typeof item + JSON.stringify(item)) ? false : (obj[typeof item + JSON.stringify(item)] = true)
    })
}
console.log(unique(array)); // [{value: 1}, {value: 2}]

ES6 的 set 和 map

set

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))
}

参考：

[1] JavaScript专题之数组去重

Programing learning note

JavaScript 数组去重