95 lines
3 KiB
JavaScript
95 lines
3 KiB
JavaScript
|
var pSlice = Array.prototype.slice;
|
||
|
|
var objectKeys = require('./lib/keys.js');
|
||
|
|
var isArguments = require('./lib/is_arguments.js');
|
||
|
|
|
||
|
|
var deepEqual = module.exports = function (actual, expected, opts) {
|
||
|
|
if (!opts) opts = {};
|
||
|
|
// 7.1. All identical values are equivalent, as determined by ===.
|
||
|
|
if (actual === expected) {
|
||
|
|
return true;
|
||
|
|
|
||
|
|
} else if (actual instanceof Date && expected instanceof Date) {
|
||
|
|
return actual.getTime() === expected.getTime();
|
||
|
|
|
||
|
|
// 7.3. Other pairs that do not both pass typeof value == 'object',
|
||
|
|
// equivalence is determined by ==.
|
||
|
|
} else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') {
|
||
|
|
return opts.strict ? actual === expected : actual == expected;
|
||
|
|
|
||
|
|
// 7.4. For all other Object pairs, including Array objects, equivalence is
|
||
|
|
// determined by having the same number of owned properties (as verified
|
||
|
|
// with Object.prototype.hasOwnProperty.call), the same set of keys
|
||
|
|
// (although not necessarily the same order), equivalent values for every
|
||
|
|
// corresponding key, and an identical 'prototype' property. Note: this
|
||
|
|
// accounts for both named and indexed properties on Arrays.
|
||
|
|
} else {
|
||
|
|
return objEquiv(actual, expected, opts);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function isUndefinedOrNull(value) {
|
||
|
|
return value === null || value === undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
function isBuffer (x) {
|
||
|
|
if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false;
|
||
|
|
if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (x.length > 0 && typeof x[0] !== 'number') return false;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
function objEquiv(a, b, opts) {
|
||
|
|
var i, key;
|
||
|
|
if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
|
||
|
|
return false;
|
||
|
|
// an identical 'prototype' property.
|
||
|
|
if (a.prototype !== b.prototype) return false;
|
||
|
|
//~~~I've managed to break Object.keys through screwy arguments passing.
|
||
|
|
// Converting to array solves the problem.
|
||
|
|
if (isArguments(a)) {
|
||
|
|
if (!isArguments(b)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
a = pSlice.call(a);
|
||
|
|
b = pSlice.call(b);
|
||
|
|
return deepEqual(a, b, opts);
|
||
|
|
}
|
||
|
|
if (isBuffer(a)) {
|
||
|
|
if (!isBuffer(b)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (a.length !== b.length) return false;
|
||
|
|
for (i = 0; i < a.length; i++) {
|
||
|
|
if (a[i] !== b[i]) return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
var ka = objectKeys(a),
|
||
|
|
kb = objectKeys(b);
|
||
|
|
} catch (e) {//happens when one is a string literal and the other isn't
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
// having the same number of owned properties (keys incorporates
|
||
|
|
// hasOwnProperty)
|
||
|
|
if (ka.length != kb.length)
|
||
|
|
return false;
|
||
|
|
//the same set of keys (although not necessarily the same order),
|
||
|
|
ka.sort();
|
||
|
|
kb.sort();
|
||
|
|
//~~~cheap key test
|
||
|
|
for (i = ka.length - 1; i >= 0; i--) {
|
||
|
|
if (ka[i] != kb[i])
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
//equivalent values for every corresponding key, and
|
||
|
|
//~~~possibly expensive deep test
|
||
|
|
for (i = ka.length - 1; i >= 0; i--) {
|
||
|
|
key = ka[i];
|
||
|
|
if (!deepEqual(a[key], b[key], opts)) return false;
|
||
|
|
}
|
||
|
|
return typeof a === typeof b;
|
||
|
|
}
|