这种类型可以用“object”进行检查吗？有待改进吗？

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

它是否与是否有任何带有 typeof b === "object" 的 b 会改变语义

？有什么我应该注意的可怕的边缘情况吗？具有非直观布尔相等或不相等的对象和本机类型之间的比较？包括浏览器中的任何错误（我指的是 IE6！）

Answer 1

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

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

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

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

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

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

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

  // 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 源代码 以查看其余部分这个函数使用的函数。

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