这种类型的“对象”检查可以改进吗？

Question

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" 会改变语义？

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

Answer 1

第二个检查与第一个检查不同完全，不，仅仅是因为 JavaScript 是弱类型的，所以至少考虑“.toString() 效应”，以及其他。例如，这些将通过第一次检查，但通过第二次：

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

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

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

一种解决方法是使用=== which is a strict comparison operator 进行值和类型检查，您也可以进行类型检查...但我不是完全 确定这就是你所追求的，因为当前的检查明确地是“不是对象”。

Answer 2

不一样。
这是一个理解原因的示例：

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;

Answer 3

从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 source code 以查看该函数使用的其余功能。

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