118 lines
4.2 KiB
JavaScript
118 lines
4.2 KiB
JavaScript
/* eslint-disable */
|
|
// underscore's deep equal function
|
|
// https://github.com/jashkenas/underscore/blob/master/underscore.js#L1189
|
|
|
|
export default function isEqual(a, b, aStack, bStack) {
|
|
// Identical objects are equal. `0 === -0`, but they aren't identical.
|
|
// See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
|
|
if (a === b) return a !== 0 || 1 / a === 1 / b;
|
|
// `null` or `undefined` only equal to itself (strict comparison).
|
|
if (a == null || b == null) return false;
|
|
// `NaN`s are equivalent, but non-reflexive.
|
|
if (a !== a) return b !== b;
|
|
// Exhaust primitive checks
|
|
var type = typeof a;
|
|
if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;
|
|
return deepEq(a, b, aStack, bStack);
|
|
}
|
|
|
|
function deepEq(a, b, aStack, bStack) {
|
|
// Compare `[[Class]]` names.
|
|
var className = toString.call(a);
|
|
if (className !== toString.call(b)) return false;
|
|
switch (className) {
|
|
// Strings, numbers, regular expressions, dates, and booleans are compared by value.
|
|
case '[object RegExp]':
|
|
// RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
|
|
case '[object String]':
|
|
// Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
|
|
// equivalent to `new String("5")`.
|
|
return '' + a === '' + b;
|
|
case '[object Number]':
|
|
// `NaN`s are equivalent, but non-reflexive.
|
|
// Object(NaN) is equivalent to NaN.
|
|
if (+a !== +a) return +b !== +b;
|
|
// An `egal` comparison is performed for other numeric values.
|
|
return +a === 0 ? 1 / +a === 1 / b : +a === +b;
|
|
case '[object Date]':
|
|
case '[object Boolean]':
|
|
// Coerce dates and booleans to numeric primitive values. Dates are compared by their
|
|
// millisecond representations. Note that invalid dates with millisecond representations
|
|
// of `NaN` are not equivalent.
|
|
return +a === +b;
|
|
case '[object Symbol]':
|
|
return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);
|
|
}
|
|
|
|
var areArrays = className === '[object Array]';
|
|
if (!areArrays) {
|
|
if (typeof a != 'object' || typeof b != 'object') return false;
|
|
|
|
// Objects with different constructors are not equivalent, but `Object`s or `Array`s
|
|
// from different frames are.
|
|
var aCtor = a.constructor,
|
|
bCtor = b.constructor;
|
|
if (
|
|
aCtor !== bCtor &&
|
|
!(
|
|
typeof aCtor === 'function' &&
|
|
aCtor instanceof aCtor &&
|
|
typeof bCtor === 'function' &&
|
|
bCtor instanceof bCtor
|
|
) &&
|
|
('constructor' in a && 'constructor' in b)
|
|
) {
|
|
return false;
|
|
}
|
|
}
|
|
// Assume equality for cyclic structures. The algorithm for detecting cyclic
|
|
// structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
|
|
|
|
// Initializing stack of traversed objects.
|
|
// It's done here since we only need them for objects and arrays comparison.
|
|
aStack = aStack || [];
|
|
bStack = bStack || [];
|
|
var length = aStack.length;
|
|
while (length--) {
|
|
// Linear search. Performance is inversely proportional to the number of
|
|
// unique nested structures.
|
|
if (aStack[length] === a) return bStack[length] === b;
|
|
}
|
|
|
|
// Add the first object to the stack of traversed objects.
|
|
aStack.push(a);
|
|
bStack.push(b);
|
|
|
|
// Recursively compare objects and arrays.
|
|
if (areArrays) {
|
|
// Compare array lengths to determine if a deep comparison is necessary.
|
|
length = a.length;
|
|
if (length !== b.length) return false;
|
|
// Deep compare the contents, ignoring non-numeric properties.
|
|
while (length--) {
|
|
if (!isEqual(a[length], b[length], aStack, bStack)) return false;
|
|
}
|
|
} else {
|
|
// Deep compare objects.
|
|
var keys = Object.keys(a),
|
|
key;
|
|
length = keys.length;
|
|
// Ensure that both objects contain the same number of properties before comparing deep equality.
|
|
if (Object.keys(b).length !== length) return false;
|
|
while (length--) {
|
|
// Deep compare each member
|
|
key = keys[length];
|
|
if (!(has(b, key) && isEqual(a[key], b[key], aStack, bStack))) return false;
|
|
}
|
|
}
|
|
// Remove the first object from the stack of traversed objects.
|
|
aStack.pop();
|
|
bStack.pop();
|
|
return true;
|
|
}
|
|
|
|
function has(obj, path) {
|
|
return obj != null && hasOwnProperty.call(obj, path);
|
|
}
|
|
/* eslint-enable */
|