本文共 2265 字，大约阅读时间需要 7 分钟。

不考虑引用数据类型的去重方法

在 JavaScript 中，去重是一个常见的需求。以下是一些常用的去重方法，以及它们的实现方式和适用场景。

1. 利用 indexOf 去重

indexOf 方法是最基础的去重方法。它通过检查当前元素是否已经存在于数组中，若存在则跳过，否则添加到目标数组中。

function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!');
        return;
    }
    const result = [];
    for (let i = 0; i < arr.length; i++) {
        if (result.indexOf(arr[i]) === -1) {
            result.push(arr[i]);
        }
    }
    return result;
}

优点：简单易懂，适合处理小规模数据。

缺点：对于大规模数据，效率较低，因为 indexOf 每次都会遍历整个结果数组。

2. ES6 Set 去重

ES6 引入了 Set 数据结构，提供了更高效的去重方法。Set 内部使用哈希表存储数据，查找和添加操作的时间复杂度均为 O(1)。

// 方法一：将 Set 转换为数组
const uniqueArray = Array.from(new Set(arr));
// 方法二：使用扩展运算符
const uniqueArray = [...new Set(arr)];

优点：效率高，适合处理大规模数据。

缺点：无法直接处理 NaN 和对象引用类型的去重问题，因为 NaN 和对象在 Set 中会被认为是相同的值。

3. 排序后相邻去除法

这种方法通过对数组进行排序，然后遍历数组，去除相邻重复元素。

function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!');
        return;
    }
    const sorted = arr.sort();
    const result = [sorted[0]];
    for (let i = 1; i < sorted.length; i++) {
        if (sorted[i] !== sorted[i - 1]) {
            result.push(sorted[i]);
        }
    }
    return result;
}

优点：简单易实现，适合处理基本类型数据。

缺点：对 NaN 和对象引用类型无法正确去重，且排序操作的时间复杂度为 O(n log n)。

4. 利用 filter 方法

filter 方法结合 indexOf，通过检查当前元素在原始数组中的位置，来判断是否需要保留当前元素。

function unique(arr) {
    return arr.filter((item, index, arr) => {
        return arr.indexOf(item, 0) === index;
    });
}

优点：代码简洁，易于理解和维护。

缺点：对于大规模数据，效率较低，且无法处理 NaN 和对象引用类型的去重问题。

考虑引用数据类型的去重方法

对于引用数据类型（如对象、数组等），传统的 indexOf 方法无法有效去重，因为引用类型的相等性判断与 === 运算符不同。

1. 利用 hasOwnProperty

hasOwnProperty 方法用于检查对象的属性，可以用于去重引用类型。

function unique(arr) {
    const obj = {};
    return arr.filter((item, index, arr) => {
        const key = typeof item + item;
        if (!obj.hasOwnProperty(key)) {
            obj[key] = true;
        }
        return false;
    });
}

优点：能够正确去重对象、数组等引用类型。

缺点：无法处理 NaN 的去重问题，因为 NaN 的类型为 number，且 NaN !== NaN。

2. 其他方法

对于更复杂的引用类型，可以结合 JSON.stringify 和 Set 来实现去重。

function unique(arr) {
    const set = new Set();
    return arr.filter(item => {
        const str = JSON.stringify(item);
        if (!set.has(str)) {
            set.add(str);
        }
        return false;
    });
}

优点：能够处理复杂的引用类型和 NaN 的去重问题。

缺点：JSON.stringify 的性能可能成为问题，尤其是处理大量复杂对象时。

转载地址：http://wwvo.baihongyu.com/