js怎么比较两个对象是否相等

function deepEqual(obj1, obj2) {
    // 1. 严格相等检查：处理基本类型、null、undefined、以及指向同一内存地址的对象
    if (obj1 === obj2) {
        return true;
    }

    // 2. 处理 NaN 的特殊情况
    if (typeof obj1 === 'number' && typeof obj2 === 'number' && isNaN(obj1) && isNaN(obj2)) {
        return true;
    }

    // 3. 检查是否都是对象且非 null
    if (typeof obj1 !== 'object' || obj1 === null || typeof obj2 !== 'object' || obj2 === null) {
        return false;
    }

    // 4. 检查构造函数是否一致，确保类型相同 (例如，都是Date对象，而不是一个Date一个普通Object)
    if (obj1.constructor !== obj2.constructor) {
        return false;
    }

    // 5. 特殊对象类型处理
    // Date 对象比较
    if (obj1 instanceof Date) {
        return obj1.getTime() === obj2.getTime();
    }
    // RegExp 对象比较
    if (obj1 instanceof RegExp) {
        return obj1.source === obj2.source && obj1.flags === obj2.flags;
    }

    // 6. 数组比较
    if (Array.isArray(obj1)) {
        if (obj1.length !== obj2.length) {
            return false;
        }
        for (let i = 0; i < obj1.length; i++) {
            if (!deepEqual(obj1[i], obj2[i])) {
                return false;
            }
        }
        return true;
    }

    // 7. 普通对象比较
    const keys1 = Object.keys(obj1);
    const keys2 = Object.keys(obj2);

    if (keys1.length !== keys2.length) {
        return false;
    }

    for (let i = 0; i < keys1.length; i++) {
        const key = keys1[i];
        // 确保 obj2 也有这个 key，并且对应的值也深度相等
        if (!Object.prototype.hasOwnProperty.call(obj2, key) || !deepEqual(obj1[key], obj2[key])) {
            return false;
        }
    }

    return true;
}

// 示例用法
// const objA = { a: 1, b: { c: 2 }, d: [3, { e: 4 }], f: new Date('2023-01-01'), g: /abc/i, h: NaN };
// const objB = { a: 1, b: { c: 2 }, d: [3, { e: 4 }], f: new Date('2023-01-01'), g: /abc/i, h: NaN };
// const objC = { a: 1, b: { c: 99 } };

// console.log(deepEqual(objA, objB)); // true
// console.log(deepEqual(objA, objC)); // false
// console.log(deepEqual({x: NaN}, {x: NaN})); // true
// console.log(deepEqual(new Date('2023-01-01'), new Date('2023-01-01'))); // true

string

number

boolean

bigint

1 === 1

'hello' === 'hello'

const obj1 = { name: 'Alice' };
const obj2 = { name: 'Alice' };

console.log(obj1 === obj2); // 结果是 false

obj1

obj2

function shallowEqual(objA, objB) {
    // 如果是同一个引用，或者都是基本类型且值相等，直接返回 true
    if (objA === objB) {
        return true;
    }

    // 如果其中一个不是对象或者为 null，那它们不相等（因为前面已经排除了 objA === objB 的情况）
    if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
        return false;
    }

    const keysA = Object.keys(objA);
    const keysB = Object.keys(objB);

    // 属性数量不一致，肯定不相等
    if (keysA.length !== keysB.length) {
        return false;
    }

    // 遍历属性，检查值是否严格相等
    for (let i = 0; i < keysA.length; i++) {
        const key = keysA[i];
        // 确保 objB 也有此属性，且值严格相等
        if (!Object.prototype.hasOwnProperty.call(objB, key) || objA[key] !== objB[key]) {
            return false;
        }
    }

    return true;
}

// 示例
// const data1 = { name: 'Bob', age: 30 };
// const data2 = { name: 'Bob', age: 30 };
// const data3 = { name: 'Bob', age: 30, city: 'NY' };
// const data4 = { name: 'Bob', details: { id: 1 } };
// const data5 = { name: 'Bob', details: { id: 1 } }; // 注意这里，details 是嵌套对象，浅比较会失败

// console.log(shallowEqual(data1, data2)); // true
// console.log(shallowEqual(data1, data3)); // false (属性数量不同)
// console.log(shallowEqual(data4, data5)); // false (因为 {id: 1} !== {id: 1}，引用不同)

data4

data5

props

state

_.isEqual