复杂数组去重的常用方法

小白目

已于 2022-08-13 15:25:09 修改

阅读量1.1k

点赞数

分类专栏：数据结构与算法文章标签： js 算法

于 2022-03-21 16:47:38 首次发布

本文链接：https://blog.csdn.net/qq_37974755/article/details/123638208

版权

数据结构与算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文详细介绍了数组去重的多种方法，包括使用Set、indexOf、includes、reduce、Map以及filter+indexOf等。对于复杂数组，通过JSON.stringify转换后再进行去重，确保了对象类型的元素也能正确处理。同时，文章提供了多个示例代码，帮助读者理解并应用这些方法。

摘要由CSDN通过智能技术生成

一、复杂数组去重

1. 用set

        function unique(arr) {
            let res = new Set();
            return arr.filter((item) => {
                let id = JSON.stringify(item);
                if (res.has(id)) {
                    return false;
                } else {
                    res.add(id);
                    return true;
                }
            })
        }
        var arr = [123, "webpank", [1, 2, 3], "123", { a: 1 }, "tencent", 123, [1, 2, 3], { a: 1 }];
        console.log(unique(arr));

        // const readline = require('readline');
        // const rl = readline.createInterface({
        //     input: process.stdin,
        //     output: process.stdout
        // });
        // rl.on('line', (line) => {
        //     let arr = JSON.parse(line)
        //     console.log(unique(arr))
        // });

2. 不用set

       const uni = (temp) => {
            const arr = [];
            const map = new Map();
            for (let i = 0; i < temp.length; i++) {
                let mid;
                // console.log(typeof temp[i]);
                if (typeof temp[i] === "object") {
                    mid = temp[i];
                    temp[i] = JSON.stringify(temp[i]);
                }
                if (map.has(temp[i])) {
                    map.set(temp[i], true);
                } else {
                    map.set(temp[i], false);
                    if (typeof mid === "object") {
                        temp[i] = JSON.parse(temp[i]);
                    }
                    arr.push(temp[i]);
                }
            }
            console.log(arr);
            return arr
        }

二、简单数组去重

1: 利用 `Set`

function uniq(arry) {
    return [...new Set(arry)]
}

2: 利用 `indexOf`

function uniq(arry) {
    var result = [];
    for (var i = 0; i < arry.length; i++) {
        if (result.indexOf(arry[i]) === -1) {
            //如 result 中没有 arry[i],则添加到数组中
            result.push(arry[i])
        }
    }
    return result
}

3: 利用 `includes`

function uniq(arry) {
    var result = [];
    for (var i = 0; i < arry.length; i++) {
        if (!result.includes(arry[i])) {
            //如 result 中没有 arry[i],则添加到数组中
            result.push(arry[i])
        }
    }
    return result;
}

4：利用 `reduce`

function uniq(arry) {
    return arry.reduce((prev, cur) => prev.includes(cur) ? prev : [...prev, cur], []);
}

5：利用 `Map`

function uniq(arry) {
    let map = new Map();
    let result = new Array();
    for (let i = 0; i < arry.length; i++) {
        if (map.has(arry[i])) {
            map.set(arry[i], true);
        } else {
            map.set(arry[i], false);
            result.push(arry[i]);
        }
    }
    return result;
}

5：利用 `fliter+indexOf`

function uniq(arr) {
   return arr.filter(function(item, index, arr) {
         //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
         return arr.indexOf(item, 0) === index;
    });
}