Mirrors/lodash
1
0
Fork 0
mirror of https://github.com/whoisclebs/lodash.git synced 2026-01-31 23:37:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rewrite _.isEqual and add support for comparing cyclic structures.

Browse Source
This commit is contained in:
Kit Goncharov
2011-07-12 19:42:36 -06:00
parent 727db393d5
commit 5c2c3ce464
2 changed files with 97 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
test/objects.js
View File

@@ -82,6 +82,46 @@ $(document).ready(function() {
ok(!_.isEqual({x: 1, y: undefined}, {x: 1, z: 2}), 'objects with the same number of undefined keys are not equal');
ok(!_.isEqual(_({x: 1, y: undefined}).chain(), _({x: 1, z: 2}).chain()), 'wrapped objects are not equal');
equals(_({x: 1, y: 2}).chain().isEqual(_({x: 1, y: 2}).chain()).value(), true, 'wrapped objects are equal');
// Objects with circular references.
var circularA = {'abc': null}, circularB = {'abc': null};
circularA.abc = circularA;
circularB.abc = circularB;
ok(_.isEqual(circularA, circularB), 'objects with a circular reference');
circularA.def = 1;
circularB.def = 1;
ok(_.isEqual(circularA, circularB), 'objects with identical properties and a circular reference');
circularA.def = 1;
circularB.def = 0;
ok(!_.isEqual(circularA, circularB), 'objects with different properties and a circular reference');
// Arrays with circular references.
circularA = [];
circularB = [];
circularA.push(circularA);
circularB.push(circularB);
ok(_.isEqual(circularA, circularB), 'arrays with a circular reference');
circularA.push('abc');
circularB.push('abc');
ok(_.isEqual(circularA, circularB), 'arrays with identical indices and a circular reference');
circularA.push('hello');
circularB.push('goodbye');
ok(!_.isEqual(circularA, circularB), 'arrays with different properties and a circular reference');
// Hybrid cyclic structures.
circularA = [{'abc': null}];
circularB = [{'abc': null}];
circularA[0].abc = circularA;
circularB[0].abc = circularB;
circularA.push(circularA);
circularB.push(circularB);
ok(_.isEqual(circularA, circularB), 'cyclic structure');
circularA[0].def = 1;
circularB[0].def = 1;
ok(_.isEqual(circularA, circularB), 'cyclic structure with identical properties');
circularA[0].def = 1;
circularB[0].def = 0;
ok(!_.isEqual(circularA, circularB), 'cyclic structure with different properties');
});
test("objects: isEmpty", function() {

97
underscore.js
View File

@@ -391,7 +391,6 @@
return -1;
};
// Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
_.lastIndexOf = function(array, item) {
if (array == null) return -1;
@@ -538,7 +537,6 @@
};
};
// Object Functions
// ----------------
@@ -596,44 +594,63 @@
};
// Perform a deep comparison to check if two objects are equal.
_.isEqual = function(a, b) {
// Check object identity.
if (a === b) return true;
// Different types?
var atype = typeof(a), btype = typeof(b);
if (atype != btype) return false;
// Basic equality test (watch out for coercions).
if (a == b) return true;
// One is falsy and the other truthy.
if ((!a && b) || (a && !b)) return false;
// Unwrap any wrapped objects.
if (a._chain) a = a._wrapped;
if (b._chain) b = b._wrapped;
// One of them implements an isEqual()?
if (a.isEqual) return a.isEqual(b);
if (b.isEqual) return b.isEqual(a);
// Check dates' integer values.
if (_.isDate(a) && _.isDate(b)) return a.getTime() === b.getTime();
// Both are NaN?
if (_.isNaN(a) && _.isNaN(b)) return false;
// Compare regular expressions.
if (_.isRegExp(a) && _.isRegExp(b))
return a.source === b.source &&
a.global === b.global &&
a.ignoreCase === b.ignoreCase &&
a.multiline === b.multiline;
// If a is not an object by this point, we can't handle it.
if (atype !== 'object') return false;
// Check for different array lengths before comparing contents.
if (a.length && (a.length !== b.length)) return false;
// Nothing else worked, deep compare the contents.
var aKeys = _.keys(a), bKeys = _.keys(b);
// Different object sizes?
if (aKeys.length != bKeys.length) return false;
// Recursive comparison of contents.
for (var key in a) if (!(key in b) || !_.isEqual(a[key], b[key])) return false;
return true;
};
_.isEqual = (function() {
function eq(a, b, stack) {
// Identical objects are equal.
if (a === b) return true;
// A strict comparison is necessary because `null == undefined`.
if (a == null) return a === b;
// Compare `[[Class]]` names.
var className = toString.call(a);
if (className != toString.call(b)) return false;
// Compare functions by reference.
if (_.isFunction(a)) return _.isFunction(b) && a == b;
// Compare strings, numbers, dates, and booleans by value.
if (_.isString(a)) return _.isString(b) && String(a) == String(b);
if (_.isNumber(a)) return _.isNumber(b) && +a == +b;
if (_.isDate(a)) return _.isDate(b) && a.getTime() == b.getTime();
if (_.isBoolean(a)) return _.isBoolean(b) && +a == +b;
// Compare RegExps by their source patterns and flags.
if (_.isRegExp(a)) return _.isRegExp(b) && a.source == b.source &&
a.global == b.global &&
a.multiline == b.multiline &&
a.ignoreCase == b.ignoreCase;
// Recursively compare objects and arrays.
if (typeof a != 'object') return false;
// Unwrap any wrapped objects.
if (a._chain) a = a._wrapped;
if (b._chain) b = b._wrapped;
// Invoke a custom `isEqual` method if one is provided.
if (a.isEqual) return a.isEqual(b);
if (b.isEqual) return b.isEqual(a);
// Compare array lengths to determine if a deep comparison is necessary.
if (a.length && (a.length !== b.length)) return false;
// Assume equality for cyclic structures.
var length = stack.length;
while (length--) {
if (stack[length] == a) return true;
}
// Add the object to the stack of traversed objects.
stack.push(a);
var result = true;
// Deep comparse the contents.
var aKeys = _.keys(a), bKeys = _.keys(b);
// Ensure that both objects contain the same number of properties.
if (result = aKeys.length == bKeys.length) {
// Recursively compare properties.
for (var key in a) {
if (!(result = key in b && eq(a[key], b[key], stack))) break;
}
}
// Remove the object from the stack of traversed objects.
stack.pop();
return result;
}
// Expose the recursive `isEqual` method.
return function(a, b) {
return eq(a, b, []);
};
})();
// Is a given array or object empty?
_.isEmpty = function(obj) {