对象数组去重

对象数组去重

平常见的大多是数组去重，那对象数组如何去重呢？

步骤

1. 如何判断两个obj 是否是相等
2. 双循环判断 res 里面是否有相同的obj，若没有，则将该对象加入到 res 数组中，若有，则跳过该对象

判断两个对象是否相等

// 判断两个对象是不是相等的
function isEqual(obj1, obj2) {
    const type = '[object Object]';
    // 判断两个变量是否为对象类型
    let isObj = (Object.prototype.toString.call(obj1) === type && Object.prototype.toString.call(obj2) === type);
    if (!isObj) {
        return false;
    }


    // 判断两个对象的长度是否相等，不相等则直接返回 fase
    let obj1Keys = Object.keys(obj1);
    let obj2Keys = Object.keys(obj2);
    if (obj1Keys.length !== obj2Keys.length) {
        return false;
    }


    // 判断两个对象的每个属性值是否相等
    for (const key in obj1) {
        // 判断两个对象的键是否相等
        if (obj2.hasOwnProperty(key)) {
            let obj1Type = toString.call(obj1[key]);
            let obj2Type = toString.call(obj2[key]);
            // 如果值是对象，则递归
            if (obj1Type === type || obj2Type === type) {
                if (!isEqual(obj1[key], obj2[key])) {
                    return false;
                }
            } else if (obj1[key] !== obj2[key]) {
                return false; // 如果不是对象，则判断值是否相等
            }
        } else {
            return false;
        }
    }
    return true; // 上面条件都通过，则返回 true
}

实现对象数组去重

const a = [
    {
        a: 1,
        b: 1
    },
    {
        a: 1
    },
    {
        a: 1
    },
    {
        b: {
            a: 1
        },
        a: 1
    },
    {
        a: 1,
        b: {
            a: 1
        }
    }
];


// 要求去重
// [
//     {
//         a: 1,
//         b: 1
//     },
//     {
//         a: 1
//     },
//     {
//         b: {
//             a: 1
//         },
//         a: 1
//     }
// ]



function unique(obj) {
    let res = [];
    let flag = false;

    for (let i in obj) {
        for (let j of res) {
            if (isEqual(obj[i], j)) {
                flag = true;
                break;
            }
        }
        if (!flag) {
            res.push(obj[i]);
        } else {
            flag = false;
        }

    }

    return res;
}


// 判断两个对象是不是相等的
function isEqual(obj1, obj2) {
    const type = '[object Object]';
    // 判断两个变量是否为对象类型
    let isObj = (Object.prototype.toString.call(obj1) === type && Object.prototype.toString.call(obj2) === type);
    if (!isObj) {
        return false;
    }


    // 判断两个对象的长度是否相等，不相等则直接返回 fase
    let obj1Keys = Object.keys(obj1);
    let obj2Keys = Object.keys(obj2);
    if (obj1Keys.length !== obj2Keys.length) {
        return false;
    }


    // 判断两个对象的每个属性值是否相等
    for (const key in obj1) {
        // 判断两个对象的键是否相等
        if (obj2.hasOwnProperty(key)) {
            let obj1Type = toString.call(obj1[key]);
            let obj2Type = toString.call(obj2[key]);
            // 如果值是对象，则递归
            if (obj1Type === type || obj2Type === type) {
                if (!isEqual(obj1[key], obj2[key])) {
                    return false;
                }
            } else if (obj1[key] !== obj2[key]) {
                return false; // 如果不是对象，则判断值是否相等
            }
        } else {
            return false;
        }
    }
    return true; // 上面条件都通过，则返回 true
}

console.log(unique(a));