Cleanup _.isEqual and make _.where of an empty array match all arrays similar to empty objects matching all objects.

lodash.js

@@ -1926,38 +1926,18 @@
       if (valClass != othClass) {
         return false;
       }
-      switch (valClass) {
-        case boolClass:
-        case dateClass:
-          // coerce dates and booleans to numbers, dates to milliseconds and booleans
-          // to `1` or `0` treating invalid dates coerced to `NaN` as not equal
-          return +value == +other;
-
-        case numberClass:
-          // treat `NaN` vs. `NaN` as equal
-          return (value != +value)
-            ? other != +other
-            // but treat `-0` vs. `+0` as not equal
-            : (value == 0 ? (1 / value == 1 / other) : value == +other);
-
-        case regexpClass:
-        case stringClass:
-          // coerce regexes to strings (http://es5.github.io/#x15.10.6.4) and
-          // treat strings primitives and string objects as equal
-          return value == String(other);
-      }
       var isArr = arrayLikeClasses[valClass],
           isErr = valClass == errorClass;
 
-      if (!support.argsClass) {
+      if (isArr) {
-        valIsArg = isArguments(value);
+        var valLength = value.length,
-        othIsArg = isArguments(other);
+            othLength = other.length;
-      }
+
-      if (!isArr) {
+        if (valLength != othLength && !(isWhere && othLength > valLength)) {
-        // exit for things like functions and DOM nodes
-        if (!(isErr || valClass == objectClass) || (!support.nodeClass && (isNode(value) || isNode(other)))) {
           return false;
         }
+      }
+      else if (isErr || (valClass == objectClass && (support.nodeClass || !(isNode(value) || isNode(other))))) {
         // unwrap any `lodash` wrapped values
         var valWrapped = hasOwnProperty.call(value, '__wrapped__'),
             othWrapped = hasOwnProperty.call(other, '__wrapped__');
@@ -1965,6 +1945,10 @@
         if (valWrapped || othWrapped) {
           return baseIsEqual(valWrapped ? value.__wrapped__ : value, othWrapped ? other.__wrapped__ : other, customizer, isWhere, stackA, stackB);
         }
+        if (!support.argsClass) {
+          valIsArg = isArguments(value);
+          othIsArg = isArguments(other);
+        }
         var hasValCtor = !valIsArg && hasOwnProperty.call(value, 'constructor'),
             hasOthCtor = !othIsArg && hasOwnProperty.call(other, 'constructor');
 
@@ -1988,6 +1972,43 @@
             return false;
           }
         }
+        var valProps = isErr ? ['message', 'name'] : keys(value),
+            othProps = isErr ? valProps : keys(other);
+
+        if (valIsArg) {
+          valProps.push('length');
+        }
+        if (othIsArg) {
+          othProps.push('length');
+        }
+        valLength = valProps.length;
+        othLength = othProps.length;
+        if (valLength != othLength && !isWhere) {
+          return false;
+        }
+      }
+      else {
+        switch (valClass) {
+          case boolClass:
+          case dateClass:
+            // coerce dates and booleans to numbers, dates to milliseconds and booleans
+            // to `1` or `0` treating invalid dates coerced to `NaN` as not equal
+            return +value == +other;
+
+          case numberClass:
+            // treat `NaN` vs. `NaN` as equal
+            return (value != +value)
+              ? other != +other
+              // but treat `-0` vs. `+0` as not equal
+              : (value == 0 ? (1 / value == 1 / other) : value == +other);
+
+          case regexpClass:
+          case stringClass:
+            // coerce regexes to strings (http://es5.github.io/#x15.10.6.4) and
+            // treat strings primitives and string objects as equal
+            return value == String(other);
+        }
+        return false;
       }
       // assume cyclic structures are equal
       // the algorithm for detecting cyclic structures is adapted from ES 5.1
@@ -1995,27 +2016,21 @@
       stackA || (stackA = []);
       stackB || (stackB = []);
 
-      var length = stackA.length;
+      var index = stackA.length;
-      while (length--) {
+      while (index--) {
-        if (stackA[length] == value) {
+        if (stackA[index] == value) {
-          return stackB[length] == other;
+          return stackB[index] == other;
         }
       }
-      var index = -1;
-
       // add `value` and `other` to the stack of traversed objects
       stackA.push(value);
       stackB.push(other);
 
       // recursively compare objects and arrays (susceptible to call stack limits)
+      result = true;
       if (isArr) {
-        var othLength = other.length;
-        length = value.length;
-        result = length == othLength;
-
-        if (result || (isWhere && othLength > length)) {
         // deep compare the contents, ignoring non-numeric properties
-          while (++index < length) {
+        while (result && ++index < valLength) {
           var valValue = value[index];
           if (isWhere) {
             var othIndex = othLength;
@@ -2032,27 +2047,10 @@
               result = baseIsEqual(valValue, othValue, customizer, isWhere, stackA, stackB);
             }
           }
-            if (!result) {
-              break;
-            }
-          }
         }
       }
       else {
-        var valProps = isErr ? ['message', 'name'] : keys(value),
+        while (result && ++index < valLength) {
-            othProps = isErr ? valProps : keys(other);
-
-        if (valIsArg) {
-          valProps.push('length');
-        }
-        if (othIsArg) {
-          othProps.push('length');
-        }
-        length = valProps.length;
-        result = length == othProps.length;
-
-        if (result || isWhere) {
-          while (++index < length) {
           var key = valProps[index];
           result = isErr || hasOwnProperty.call(other, key);
 
@@ -2064,10 +2062,6 @@
               result = baseIsEqual(valValue, othValue, customizer, isWhere, stackA, stackB);
             }
           }
-            if (!result) {
-              break;
-            }
-          }
         }
       }
       stackA.pop();

test/test.js

@@ -10663,7 +10663,7 @@
       deepEqual(actual, [collection[1]]);
 
       actual = _.where(collection, { 'a': [] });
-      deepEqual(actual, []);
+      deepEqual(actual, collection);
 
       actual = _.where(collection, { 'a': ['b', 'd'] });
       deepEqual(actual, []);