为何instanceof运算符判断对象类型比constructor属性更安全？

Great question! The core issue here is that the constructor property is surprisingly fragile, while instanceof relies on JavaScript's prototype chain mechanics—something far more reliable for type checking. Let's break down the key reasons:

• constructor can be easily overwritten
  Unlike the underlying prototype chain, the constructor property is mutable. Any code can change it intentionally or accidentally, which breaks your type checks. For example:

  function Person() {}
  const person = new Person();
  
  // Oops, someone modified the constructor
  person.constructor = Object;
  
  console.log(person.constructor === Person); // false (wrong!)
  console.log(person instanceof Person); // true (still correct)
  

  This makes constructor checks risky in any codebase where you don't have full control over object creation or modification.

• Prototype chain rewrites break constructor by default
  When you rewrite a constructor's prototype (a common pattern for adding methods), the default constructor property gets lost and points to Object instead of your custom constructor—unless you explicitly reset it. Most developers forget this step, leading to incorrect checks:

  function Person() {}
  // Rewrite the prototype to add methods
  Person.prototype = {
    greet() { console.log("Hello!"); }
  };
  const person = new Person();
  
  console.log(person.constructor === Person); // false (points to Object!)
  console.log(person instanceof Person); // true (still correctly identifies the type)
  

• instanceof reflects the full prototype chain
  As you saw in the examples, objects in JavaScript inherit from multiple levels in the prototype chain (e.g., a Person instance is also an Object instance). instanceof checks if the constructor's prototype exists anywhere in the object's prototype chain, which gives you a more accurate picture of the object's type relationships. The constructor property only points to the immediate constructor (when it's working correctly), so it can't capture this broader inheritance context.

While constructor might work in trivial, controlled scenarios, its lack of robustness makes it a poor choice for production code. instanceof is the safer, more reliable option because it's tied to JavaScript's fundamental prototype-based inheritance system, which is far harder to accidentally break.

内容的提问来源于stack exchange，提问作者Ayman Morsy