/**
本模块对外提供一个对象相等与否的浅层比较方法
**/
'use strict';

const hasOwnProperty = Object.prototype.hasOwnProperty;

/**
 * 一个工具函数: Object.is 方法,
 * inlined Object.is polyfill to avoid requiring consumers ship their own
 * 算法来自 :
 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
 */
function is(x, y) {
    // SameValue algorithm
    if (x === y) {
        // Steps 1-5, 7-10
        // Steps 6.b-6.e: +0 != -0
        // Added the nonzero y check to make Flow happy, but it is redundant
        return x !== 0 || y !== 0 || 1 / x === 1 / y;
    } else {
        // Step 6.a: NaN == NaN
        return x !== x && y !== y;
    }
}

/**
 * 使用浅层比较看两个对象是否相等，比较方法 :
 * 1. 如果使用上面的 is 判断两个相等，则认为两个对象相等，否则
 * 2. 如果被比较的两个对象有任何一个不是 object, 或者是 null，就认为两个对象不相等，否则
 * 3. 两个对象的自有属性集合相等 :
 *          1. 元素个数一样,并且
 *          2. 同名属性的值使用上面的 is 方法比较的结果为真
 * Performs equality by iterating through keys on an object and returning false
 * when any key has values which are not strictly equal between the arguments.
 * Returns true when the values of all keys are strictly equal.
 */
function shallowEqual(objA, objB) {
    if (is(objA, objB)) {
        // 如果使用上面的 is 判断两个相等，则认为两个对象相等
        return true;
    }
    if (
        typeof objA !== 'object' ||
        objA === null ||
        typeof objB !== 'object' ||
        objB === null
    ) {
        // 如果被比较的两个对象有任何一个不是 object, 或者是 null，就认为两个对象不相等
        return false;
    }

    // 两个对象的自有属性集合相等
    const keysA = Object.keys(objA);
    const keysB = Object.keys(objB);

    if (keysA.length !== keysB.length) {
        return false;
    }

    // Test for A's keys different from B.
    for (let i = 0; i < keysA.length; i++) {
        if (
            !hasOwnProperty.call(objB, keysA[i]) ||
            !is(objA[keysA[i]], objB[keysA[i]])
        ) {
            return false;
        }
    }

    return true;
}

module.exports = shallowEqual;