26.判断两个对象相等.md

如何判断两个对象相等？(0.1+0.2问题引申)

Note

• 0.1 + 0.2 = 0.3 吗？
• TODO 因为 JavaScript 采用了IEEE_754 浮点数表示法(几乎所有现代编程语言所采用)，这是一种二进制表示法

// v1: 用于过滤掉简单的类型比较，复杂的对象使用deepEq处理
function eq(a, b) {
    // 区别+0 和 -0
    if (a === b) return a !== 0 || 1 / a === 1 / b;

    // 如果有一个为null，退出函数（null === null, true; undefined === undefined, true）
    if (a == null || b == null) return false;

    // 判断NaN(a, b都不和自身相等的话，就为NaN)
    if (a !== a) return b !== b;

    // a是基础数据类型，b是对象的话
    let typeOfA = typeof a;
    if (typeOfA !== 'function' && typeOfA !== 'object' && typeof b !== 'object') {
        return false;
    }

    // 对于其他复杂的对象类型，开始进行进一步的比较
    return deepEq(a, b);
}


// v2: 对象的比较
const toString = Object.prototype.toString;

function isFunction(obj) {
    return toString.call(obj) === '[object Function]';
}

function deepEq(a, b) {
    let className = toString.call(a);
    if (className !== toString.call(b)) return false;

    switch (className) {
        case '[object RegExp]':
        case '[object String]':
            return '' + a === '' + b;
        case '[object Number]':
            // NaN
            if (+a !== +a) return +b !== +b;
            // +0, -0
            return +a === 0 ? 1 / +a === 1 / b : +a === +b;
        case '[object Date]':
        case '[object Boolean]':
            return +a === +b;
    }

    // 构造函数的实例如何判断呢？
    let isArray = className === '[object Array]';
    if (!isArray) {
        // 如果不是数组的话（过滤掉函数的情况）
        if (typeof a != 'object' || typeof b != 'object') return false;

        // 看a，b的构造函数
        let aConstructor = a.constructor;
        let bConstructor = b.constructor;

        // aCtor 和 bCtor 必须都存在并且都不是 Object 构造函数的情况下，aCtor 不等于 bCtor， 那这两个对象就真的不相等啦
        if (
            aConstructor !== bConstructor
            && !(
                isFunction(aConstructor)
                && aConstructor instanceof aConstructor
                && isFunction(bConstructor)
                && bConstructor instanceof bConstructor
            )
            && (
            'constructor' in a
            && 'constructor' in b)
        ) {
            return false;
        }
    }

    // 如果是数组的话
    else if (isArray) {
        let length = a.length;
        if (length !== b.length) return false;

        // 比较数组的每一项是否相同
        while (length--) {
            if (!eq(a[length], b[length])) {
                return false;
            }
        }
    }
    else {
        let keys = Object.keys(a), key;
        length = keys.length;

        if (Object.keys(b).length !== length) return false;

        while (length--) {
            key = keys[length];
            if (!(b.hasOwnProperty(key)) && eq(a[key], b[key])) {
                return false;
            }
        }

    }
    return true;
}

// v3. 循环引用问题？？？
let a, b;

a = { foo: { b: { foo: { c: { foo: null } } } } };
b = { foo: { b: { foo: { c: { foo: null } } } } };
a.foo.b.foo.c.foo = a;
b.foo.b.foo.c.foo = b;


// a 和 b是否相等呢？
/**
 *  aStack 和 bStack，用来储存 a 和 b 递归比较过程中的 a 和 b 的值
 * @param a
 * @param b
 * @param aStack
 * @param bStack
 * @return {boolean|boolean|*}
 */
function eq(a, b, aStack, bStack) {
    if (typeof a === 'number') {
        return a === b;
    }

    return deepEq(a, b, aStack, bStack);
}

function deepEq(a, b, aStack, bStack) {
    aStack = aStack || [];
    bStack = bStack || [];

    let length = aStack.length;

    while (length--) {
        if (aStack[length] === a) {
            return bStack[length] === b;
        }
    }

    aStack.push(a);
    bStack.push(b);

    let keys = Object.keys(a), key;
    length = keys.length;

    while (length--) {
        key = keys[length]

        console.log(a[key], b[key], aStack, bStack)

        if (!eq(a[key], b[key], aStack, bStack)) return false;
    }

    // aStack.pop();
    // bStack.pop();
    return true;
}


console.log(eq(a, b))


// v5. 最终版本
var toString = Object.prototype.toString;

function isFunction(obj) {
    return toString.call(obj) === '[object Function]'
}

function eq(a, b, aStack, bStack) {

    // === 结果为 true 的区别出 +0 和 -0
    if (a === b) return a !== 0 || 1 / a === 1 / b;

    // typeof null 的结果为 object ，这里做判断，是为了让有 null 的情况尽早退出函数
    if (a == null || b == null) return false;

    // 判断 NaN
    if (a !== a) return b !== b;

    // 判断参数 a 类型，如果是基本类型，在这里可以直接返回 false
    var type = typeof a;
    if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;

    // 更复杂的对象使用 deepEq 函数进行深度比较
    return deepEq(a, b, aStack, bStack);
};

function deepEq(a, b, aStack, bStack) {

    // a 和 b 的内部属性 [[class]] 相同时 返回 true
    var className = toString.call(a);
    if (className !== toString.call(b)) return false;

    switch (className) {
        case '[object RegExp]':
        case '[object String]':
            return '' + a === '' + b;
        case '[object Number]':
            if (+a !== +a) return +b !== +b;
            return +a === 0 ? 1 / +a === 1 / b : +a === +b;
        case '[object Date]':
        case '[object Boolean]':
            return +a === +b;
    }

    var areArrays = className === '[object Array]';
    // 不是数组
    if (!areArrays) {
        // 过滤掉两个函数的情况
        if (typeof a != 'object' || typeof b != 'object') return false;

        var aCtor = a.constructor,
            bCtor = b.constructor;
        // aCtor 和 bCtor 必须都存在并且都不是 Object 构造函数的情况下，aCtor 不等于 bCtor， 那这两个对象就真的不相等啦
        if (aCtor !== bCtor && !(isFunction(aCtor) && aCtor instanceof aCtor && isFunction(bCtor) && bCtor instanceof bCtor) && ('constructor' in a && 'constructor' in b)) {
            return false;
        }
    }


    aStack = aStack || [];
    bStack = bStack || [];
    var length = aStack.length;

    // 检查是否有循环引用的部分
    while (length--) {
        // 比较aStack中的每一项数据和bStack中的每一项数据，分别与a, b 比较
        if (aStack[length] === a) {
            return bStack[length] === b;
        }
    }

    aStack.push(a);
    bStack.push(b);

    // 数组判断
    if (areArrays) {

        length = a.length;
        if (length !== b.length) return false;

        while (length--) {
            if (!eq(a[length], b[length], aStack, bStack)) return false;
        }
    }
    // 对象判断
    else {

        var keys = Object.keys(a),
            key;
        length = keys.length;

        if (Object.keys(b).length !== length) return false;
        while (length--) {

            key = keys[length];
            if (!(b.hasOwnProperty(key) && eq(a[key], b[key], aStack, bStack))) return false;
        }
    }

    aStack.pop();
    bStack.pop();
    return true;

}

console.log(eq(0, 0)) // true
console.log(eq(0, -0)) // false

console.log(eq(NaN, NaN)); // true
console.log(eq(Number(NaN), Number(NaN))); // true

console.log(eq('Curly', new String('Curly'))); // true

console.log(eq([1], [1])); // true
console.log(eq({ value: 1 }, { value: 1 })); // true

var a, b;

a = { foo: { b: { foo: { c: { foo: null } } } } };
b = { foo: { b: { foo: { c: { foo: null } } } } };
a.foo.b.foo.c.foo = a;
b.foo.b.foo.c.foo = b;

console.log(eq(a, b)) // true