这只是对这里所有其他解释的补充知识——我不建议在所有地方都使用.constructor。

TL;DR:在typeof不是一个选项的情况下，并且当你知道你不关心原型链的时候，Object.prototype.constructor可以是一个可行的甚至比instanceof更好的选择:

x instanceof Y
x.constructor === Y

它从1.1开始就在标准中了，所以不用担心向后兼容性。

Muhammad Umer也在这里的一个评论中简要地提到了这一点。它适用于所有有原型的东西——所以所有不是null或未定义的东西:

// (null).constructor;      // TypeError: null has no properties
// (undefined).constructor; // TypeError: undefined has no properties

(1).constructor;                 // function Number
''.constructor;                  // function String
([]).constructor;                // function Array
(new Uint8Array(0)).constructor; // function Uint8Array
false.constructor;               // function Boolean()
true.constructor;                // function Boolean()

(Symbol('foo')).constructor;     // function Symbol()
// Symbols work, just remember that this is not an actual constructor:
// new Symbol('foo'); //TypeError: Symbol is not a constructor

Array.prototype === window.frames.Array;               // false
Array.constructor === window.frames.Array.constructor; // true

此外，根据您的用例，它可能比instanceof快得多(原因可能是它不需要检查整个原型链)。在我的情况下，我需要一个快速的方法来检查一个值是否是一个类型数组:

function isTypedArrayConstructor(obj) {
  switch (obj && obj.constructor){
    case Uint8Array:
    case Float32Array:
    case Uint16Array:
    case Uint32Array:
    case Int32Array:
    case Float64Array:
    case Int8Array:
    case Uint8ClampedArray:
    case Int16Array:
      return true;
    default:
      return false;
  }
}

function isTypedArrayInstanceOf(obj) {
  return obj instanceof Uint8Array ||
    obj instanceof Float32Array ||
    obj instanceof Uint16Array ||
    obj instanceof Uint32Array ||
    obj instanceof Int32Array ||
    obj instanceof Float64Array ||
    obj instanceof Int8Array ||
    obj instanceof Uint8ClampedArray ||
    obj instanceof Int16Array;
}

https://run.perf.zone/view/isTypedArray-constructor-vs-instanceof-1519140393812

结果是:

Chrome 64.0.3282.167(64位，Windows)

Firefox 59.0b10(64位，Windows)

出于好奇，我针对typeof做了一个快速的玩具基准测试;令人惊讶的是，它的表现并没有差到哪里去，而且在Chrome中似乎还要快一点:

let s = 0,
    n = 0;

function typeofSwitch(t) {
    switch (typeof t) {
        case "string":
            return ++s;
        case "number":
            return ++n;
        default:
            return 0;
    }
}

// note: no test for null or undefined here
function constructorSwitch(t) {
    switch (t.constructor) {
        case String:
            return ++s;
        case Number:
            return ++n;
        default:
            return 0;
    }
}

let vals = [];
for (let i = 0; i < 1000000; i++) {
    vals.push(Math.random() <= 0.5 ? 0 : 'A');
}

https://run.perf.zone/view/typeof-vs-constructor-string-or-number-1519142623570

注意:函数列表的顺序在图像之间切换!

Chrome 64.0.3282.167(64位，Windows)

Firefox 59.0b10(64位，Windows)

注意:函数列表的顺序在图像之间切换!

使用typeof的一个很好的理由是变量可能是未定义的。

alert(typeof undefinedVariable); // alerts the string "undefined"
alert(undefinedVariable instanceof Object); // throws an exception

使用instanceof的一个很好的理由是变量可能为空。

var myNullVar = null;
alert(typeof myNullVar ); // alerts the string "object"
alert(myNullVar  instanceof Object); // alerts "false"

所以在我看来，这取决于你在检查什么类型的数据。

使用instanceof，因为如果你改变了类的名字，你会得到一个编译器错误。

没有必要用上面的大量例子来压倒你，只需要记住两个观点:

typeof var; is an unary operator will return the original type or root type of var. so that it will return primitive types(string, number, bigint, boolean, undefined, and symbol) or object type. in case of higher-level object, like built-in objects (String, Number, Boolean, Array..) or complex or custom objects, all of them is object root type, but instance type built base on them is vary(like OOP class inheritance concept), here a instanceof A - a binary operator - will help you, it will go through the prototype chain to check whether constructor of the right operand(A) appears or not.

所以当你想检查“根类型”或使用基元变量时，使用“typeof”，否则使用“instanceof”。

Null是一种特殊情况，它看起来很原始，但实际上是object的特殊情况。使用a === null代替检查null。

另一方面，function也是一种特殊情况，它是内置对象，但typeof返回函数

正如你所看到的，instanceof必须遍历原型链，而typeof只检查根类型一次，所以很容易理解为什么typeof比instanceof快

instanceof将不适用于原语，例如"foo" instanceof String将返回false，而typeof "foo" == " String "将返回true。

另一方面，当涉及到自定义对象(或类，无论你想叫它们什么)时，typeof可能不会做你想做的事情。例如:

function Dog() {}
var obj = new Dog;
typeof obj == 'Dog' // false, typeof obj is actually "object"
obj instanceof Dog  // true, what we want in this case

函数碰巧既是“函数”原语，又是“函数”的实例，这有点奇怪，因为它不像其他原语类型那样工作，例如。

(typeof function(){} == 'function') == (function(){} instanceof Function)

but

(typeof 'foo' == 'string') != ('foo' instanceof String)

当然这很重要........！

让我们用例子来解释一下。在我们的例子中，我们将以两种不同的方式声明函数。

我们将同时使用函数声明和函数构造函数。我们将了解typeof和instanceof在这两种不同场景中的行为。

使用函数声明创建函数:

function MyFunc(){  }

typeof Myfunc == 'function' // true

MyFunc instanceof Function // false

对于这种不同的结果，可能的解释是，因为我们做了一个函数声明，typeof可以理解它是一个函数。因为typeof检查typeof的表达式是否被操作，在我们的例子中，MyFunc是否实现了Call Method。如果它实现了Call方法，它就是一个函数。为了澄清，请检查ecmascript的typeof规范。

使用函数构造函数创建函数:

var MyFunc2 = new Function('a','b','return a+b') // A function constructor is used 

typeof MyFunc2 == 'function' // true

MyFunc2 instanceof Function // true

这里typeof断言MyFunc2是一个函数，也是一个instanceof操作符。我们已经知道typeof检查MyFunc2是否实现了Call方法。由于MyFunc2是一个函数，它实现了调用方法，这就是typeof如何知道它是一个函数。另一方面，我们使用函数构造函数来创建MyFunc2，它成为函数构造函数的一个实例。这就是为什么instanceof也解析为true。

用什么更安全?

我们可以看到，在这两种情况下，typeof操作符都可以成功地断言我们在处理一个函数，它比instanceof更安全。instanceof在函数声明的情况下将失败，因为函数声明不是function构造函数的实例。

最佳实践:

正如Gary Rafferty所建议的，最好的方法应该同时使用typeof和instanceof。

  function isFunction(functionItem) {

        return typeof(functionItem) == 'function' || functionItem instanceof Function;

  }

  isFunction(MyFunc) // invoke it by passing our test function as parameter