数组对象根据关键id去重

        const objArr = [
            { id: 1, name: 'Alice' },
            { id: 2, name: 'Bob' },
            { id: 1, name: 'Carol' },
            { id: 3, name: 'Dave' },
            { id: 2, name: 'Eve' }
        ];

数组根据关键id去重得到结果为

        [
            { id: 1, name: 'Alice' },
            { id: 2, name: 'Bob' },
            { id: 1, name: 'Carol' },
        ];

一、循环遍历

        const objArr = [
            { id: 1, name: 'Alice' },
            { id: 2, name: 'Bob' },
            { id: 1, name: 'Carol' },
            { id: 3, name: 'Dave' },
            { id: 2, name: 'Eve' }
        ];

        const uniqueObjArr = [];
        const idMap = {};
        objArr.forEach(item => {
            if (!idMap[item.id]) {
                idMap[item.id] = true;
                uniqueObjArr.push(item);
            }
        });

        console.log(uniqueObjArr);

思路：
1.定义一个新数组uniqueObjArr用于保存去重后的对象数组，定义一个对象idMap来记录每个id是否出现过。
2.使用forEach方法遍历原数组objArr，对于每一个对象item，如果idMap中没有记录该对象的id，则将该对象添加到uniqueObjArr中，并将idMap中该id的值设置为true。
注意：这种方法只能去重对象中的id属性，如果有不同的对象拥有相同的非id属性，也会被认为是不同的对象。

二、Set数据结构

        const objArr = [
            { id: 1, name: 'Alice' },
            { id: 2, name: 'Bob' },
            { id: 1, name: 'Carol' },
            { id: 3, name: 'Dave' },
            { id: 2, name: 'Eve' }
        ];

        const uniqueObjArr = Array.from(new Set(objArr.map(item => item.id)))
            .map(id => {
                return objArr.find(item => item.id === id);
            });

        console.log(uniqueObjArr);

思路：
1.使用map方法将objArr中的对象映射为只包含id属性的数组。
2.使用Set数据结构来对这个数组进行去重，得到一个只包含唯一id的数组。
3.使用map方法，根据这个唯一id的数组，从objArr中找到对应的对象，得到去重后的对象数组uniqueObjArr。
注意：这种方法是对所有的属性进行去重，而不是对特定的id属性进行去重，因此如果有不同的对象拥有相同的非id属性，也会被去重。如果需要根据某个特定的属性进行去重，可以在map方法中只取这个属性，并在find方法中使用这个属性进行比较。

三、使用reduce

        const objArr = [
            { id: 1, name: 'Alice' },
            { id: 2, name: 'Bob' },
            { id: 1, name: 'Carol' },
            { id: 3, name: 'Dave' },
            { id: 2, name: 'Eve' }
        ];

        const uniqueObjArr = objArr.reduce((prev, item) => {
            const index = prev.findIndex(obj => obj.id === item.id);
            if (index === -1) {
                prev.push(item);
            }
            return prev;
        }, []);

        console.log(uniqueObjArr);

在reduce方法内部遍历原数组，对于每一个对象item，使用数组的findIndex方法查找新数组中是否存在相同id的对象，如果不存在，就将其添加到新数组中。
注意：由于每次循环会调用findIndex方法，时间复杂度较高，特别是在数组很大的情况下，可能会影响性能。

四、使用filter

        const objArr = [
            { id: 1, name: 'Alice' },
            { id: 2, name: 'Bob' },
            { id: 1, name: 'Carol' },
            { id: 3, name: 'Dave' },
            { id: 2, name: 'Eve' }
        ];

        const uniqueObjArr = objArr.filter((item, index, arr) => {
            const firstIndex = arr.findIndex(obj => obj.id === item.id);
            return firstIndex === index;
        });

        console.log(uniqueObjArr);

在filter方法内部遍历原数组，使用一个对象来记录每个id第一次出现的位置，然后根据这个位置进行过滤，得到去重后的数组。
这种方法的好处是不需要自己定义新数组，会返回一个新数组。
注意：由于每次循环会调用findIndex方法，时间复杂度较高，特别是在数组很大的情况下，可能会影响性能。