构造函数vs . typeof来检测JavaScript中的类型

Question

在这个问题中我没有看到使用构造函数的建议。

所以不是typeof callback == "function"

我将使用callback && (callback.constructor==Function)。

对我来说，在运行时性能和编码安全方面，与内存指针比较总是比与字符串比较好。

为什么不使用构造函数来检测所有类型，而忘记丑陋的typeof呢?

适用于所有基本类型、函数和数组:

undefined === undefined
null === null
[1,2,3].constructor == Array 
(1).constructor == Number
(true).constructor == Boolean
(()=>null).constructor == Function
'abc'.constructor == String
(new Date()).constructor == Date
else it's an object, where instanceof helps to detect it's parents if needed.

如果字符串实习可以依赖，那么运行时性能优势就消失了。但是安全编码的优势仍然存在。

Answer 1

instanceof更好，因为它与继承构造函数一起工作。.constructor是对象上的可变属性，所以检查它不是一件好事，因为可以简单地更改它。你不能改变instanceof的东西。

const x = new Date();
console.log("Date Constructor", x.constructor);
x.constructor = "herpderpderp";
console.log("Date Constructor", x.constructor);

Answer 2

您还可以通过使用getPrototypeOf和isPrototypeOf为这两个测试定义您自己的函数，这些函数也可以在原语上工作。例如:

function typeOf(obj) {
    return Object.getPrototypeOf(obj).constructor;
}
typeOf(2) === Number // true
typeOf("cats") === String // true
class Foo {}
typeOf(new Foo()) === Foo // true
class Bar extends Foo {}
typeOf(new Bar()) === Bar // true
typeOf(new Bar()) === Foo // false    
var b = new Number(3)
if (typeOf(b) === Number) {
    console.log(b.valueOf() + 5)
}

和

function instanceOf(obj, type) {
    var objType = typeOf(obj)
    return (
        // Allow native instanceof in case of Symbol.hasInstance
        obj instanceof type ||
        // Handle case where is of type type
        typeOf(obj) === type ||
        // Handle general case
        type.isPrototypeOf(objType) || 
        // Handle special case where type.prototype acts as a
        // prototype of the object but its type isn't in the
        // prototype chain of the obj's type
        // OPTIONALLY remove this case if you don't want
        // primitives to be considered instances of Object
        type.prototype.isPrototypeOf(objType.prototype)
    );
}
instanceOf(3, Number) // true
instanceOf(new Number("2"), Number) // true
instanceOf(2, Number) // true, OPTIONAL with the last condition
                      // but is probably preferable as 2 does
                      // indeed get all methods of Objects
class Hat {}
instanceOf(new Hat(), Hat) // true
class Fedora extends Hat {}
instanceOf(new Fedora(), Fedora) // true
instanceOf(new Fedora(), Hat) // true
instanceOf(new Fedora(), Object) // true