3 
if (typeof a !== "object" && typeof b !== "object") {
    return a == b;
}
... // check pairwise equality of object a & b using `for in`

是不是一样

if (typeof a !== "object") {
    return a == b;
}

有什么b可以typeof b === "object"改变语义的吗？

我应该注意哪些可怕的边缘情况？具有非直观布尔相等或不等式的 aobject和 a之间的比较？native type包括浏览器中的任何错误（我的意思是你的 IE6！）

4

3 回答 3

1

这是不一样的。
这是一个例子来理解为什么：

var a = "a string";
var b = new String("a string");
console.log(typeof a);//"string" !== "object"
console.log(typeof b);//"object" === "object"
console.log('"' + a + '" ' + (a==b?"==":"!=") + ' "' + b + '"');

同样的事情也可能发生在数字上：

var a = 1;
var b = new Number(1);

由于显而易见的原因，您的两个 if 语句不一样。您可以通过使用运营商满足旅游需求
来“改进”您的类型检查：instanceof

if ((typeof a !== "object" || a instanceof Number || a instanceof String) &&
    (typeof b !== "object" || b instanceof Number || b instanceof String))
    return a == b;
于 2011-02-17T21:04:41.230 回答
1

第二个检查和第一个不太一样，不，只是因为 JavaScript 是弱类型的，所以至少要考虑“.toString()效果”，以及其他。例如，这些将失败第一次检查，但通过第二次：

var a = "[object Object]";
var b = {};

或者，更简单一点（显示您可能要考虑的案例......但这通过了两项检查）：

var a = 0;
var b = "0";

一种解决方法是使用严格的比较运算符进行值和类型检查，您也可以进行类型检查......但我不完全确定这就是您所追求的，因为当前检查明确“不是一个东西”。===

于 2011-02-17T21:05:26.507 回答
1

看看来自Underscore.js的isEqual。它“在两个对象之间执行优化的深度比较，以确定它们是否应该被视为相等。” 它适用于所有类型的变量。这是它的实现方式：

  // 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);
    // 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;
  };

请参阅Underscore.js 源代码以查看该函数使用的其余函数。

很容易错过一些边缘情况，所以我建议使用像这样的经过良好测试的代码，而不是重新发明轮子。

于 2011-02-17T21:27:52.323 回答