JavaScript 中的 instanceof 底层算法：如何沿着原型链递归判断类型 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位编程爱好者，大家好！

今天我们将深入探讨 JavaScript 中一个看似简单实则内涵丰富的运算符——instanceof。它在我们的日常开发中扮演着重要的角色，用于判断一个对象是否是某个构造函数（或类）的实例。然而，其背后的工作机制远不止表面那么简单，它涉及到 JavaScript 对象模型的核心——原型链。

本讲座旨在剥开 instanceof 的表象，直抵其底层算法，揭示它是如何沿着原型链递归地判断类型。我们将通过详尽的解释、丰富的代码示例和对潜在陷阱的分析，帮助大家建立对 instanceof 全面而深刻的理解。

1. 引言：类型判断的基石与 `instanceof` 的魅力

在动态类型的 JavaScript 中，准确地判断变量的类型是编写健壮代码的关键一环。我们经常需要知道一个变量是字符串、数字、数组，还是一个自定义类的实例。instanceof 运算符正是为此而生，它提供了一种检查对象与特定构造函数之间继承关系的能力。

让我们从一个简单的例子开始：

// 定义一个动物类
class Animal {
    constructor(name) {
        this.name = name;
    }
    speak() {
        console.log(`${this.name} makes a sound.`);
    }
}

// 定义一个狗类，继承自动物类
class Dog extends Animal {
    constructor(name, breed) {
        super(name);
        this.breed = breed;
    }
    speak() {
        console.log(`${this.name} barks.`);
    }
}

// 创建一个狗的实例
const myDog = new Dog('Buddy', 'Golden Retriever');
const myCat = { name: 'Whiskers' }; // 普通对象

console.log(myDog instanceof Dog);    // 输出: true
console.log(myDog instanceof Animal); // 输出: true
console.log(myDog instanceof Object); // 输出: true

console.log(myCat instanceof Dog);    // 输出: false
console.log(myDog instanceof String); // 输出: false
console.log(123 instanceof Number);   // 输出: false (原始值不能是实例)
console.log(new Number(123) instanceof Number); // 输出: true (包装对象是实例)

从上面的例子可以看出，myDog 不仅是 Dog 类的实例，同时也是其父类 Animal 和 Object 类的实例。这引出了一个核心问题：instanceof 是如何得知一个对象属于其父类乃至 Object 类的呢？答案就隐藏在 JavaScript 的原型链机制中。

2. JavaScript 原型机制：一切的根源

要理解 instanceof，我们必须首先掌握 JavaScript 的原型机制。这是 JavaScript 实现继承和对象复用的核心。

2.1 什么是原型 (Prototype)？

在 JavaScript 中，每个对象都有一个内部属性，称为 [[Prototype]]。这个属性指向另一个对象，也就是这个对象的“原型”。我们可以通过几种方式访问它：

__proto__ 属性 (已废弃，但不建议在生产环境中使用，仅用于学习和调试)：这是一个非标准的属性，但浏览器广泛支持。
Object.getPrototypeOf() 方法 (推荐)：这是获取对象原型的标准且推荐的方式。

当我们尝试访问一个对象的某个属性或方法时，如果该对象本身没有这个属性或方法，JavaScript 引擎就会沿着其 [[Prototype]] 向上查找。

2.2 原型链 (Prototype Chain)

如果一个对象的 [[Prototype]] 指向的对象（即它的原型）也没有这个属性或方法，那么引擎会继续查找其原型的 [[Prototype]]，如此往复，直到找到该属性或方法，或者直到原型链的末端——null。这个由一系列原型对象链接起来的结构就是原型链。

2.3 构造函数与原型

原型机制与构造函数（以及 ES6 的类）紧密相关：

构造函数的 prototype 属性：每个函数（包括用作构造函数的函数和 ES6 的类）都有一个名为 prototype 的公共属性。这个 prototype 属性是一个普通对象，它包含所有由该构造函数创建的实例所共享的属性和方法。
实例的 [[Prototype]] 属性：当我们使用 new 关键字调用一个构造函数时，会创建一个新的对象。这个新对象的内部 [[Prototype]] 属性会被自动设置为构造函数的 prototype 属性所指向的对象。

让我们通过一个具体的例子来描绘原型链：

// 重新使用之前的类定义
class Animal {
    constructor(name) { this.name = name; }
}
class Dog extends Animal {
    constructor(name, breed) { super(name); this.breed = breed; }
}

const myDog = new Dog('Buddy', 'Golden Retriever');

// 探索 myDog 的原型链
console.log(`myDog 的原型是 Dog.prototype: ${Object.getPrototypeOf(myDog) === Dog.prototype}`);
// 输出: myDog 的原型是 Dog.prototype: true

console.log(`Dog.prototype 的原型是 Animal.prototype: ${Object.getPrototypeOf(Dog.prototype) === Animal.prototype}`);
// 输出: Dog.prototype 的原型是 Animal.prototype: true

console.log(`Animal.prototype 的原型是 Object.prototype: ${Object.getPrototypeOf(Animal.prototype) === Object.prototype}`);
// 输出: Animal.prototype 的原型是 Object.prototype: true

console.log(`Object.prototype 的原型是 null: ${Object.getPrototypeOf(Object.prototype) === null}`);
// 输出: Object.prototype 的原型是 null: true

这段代码清晰地展示了 myDog 的原型链：

myDog (实例)
    -> [[Prototype]] 指向 Dog.prototype
        -> Dog.prototype (原型对象)
            -> [[Prototype]] 指向 Animal.prototype
                -> Animal.prototype (原型对象)
                    -> [[Prototype]] 指向 Object.prototype
                        -> Object.prototype (原型对象)
                            -> [[Prototype]] 指向 null (原型链末端)

现在，我们有了理解 instanceof 所需的基础知识。

3. `instanceof` 运算符的精确定义

instanceof 运算符的语法是 object instanceof constructor。它的核心作用是检查 constructor.prototype 是否存在于 object 的原型链中的任何位置。

根据 ECMAScript 规范，instanceof 运算符的执行过程会涉及到一个抽象操作，通常被称为 OrdinaryHasInstance(C, O)，其中 C 代表构造函数（constructor），O 代表被检查的对象（object）。

其基本逻辑可以概括为以下步骤：

类型检查：
- 首先，它会检查右操作数 constructor 是否是一个函数（或可调用对象）。如果不是，则抛出 TypeError。
- 然后，它会尝试获取 constructor.prototype 的值。如果 constructor.prototype 不是一个对象（例如 null 或原始值），也会抛出 TypeError。
- 左操作数 object 可以是任何类型。如果 object 是 null 或 undefined，或者任何非对象（原始值），则 instanceof 将直接返回 false，因为它无法拥有原型链。
原型链遍历：
- 获取 object 的 [[Prototype]]（即 Object.getPrototypeOf(object)）。
- 在一个循环中，不断地将当前的原型与 constructor.prototype 进行严格相等 (===) 比较。
- 如果两者相等，则表示找到了匹配，instanceof 返回 true。
- 如果当前原型为 null（到达原型链的末端），仍未找到匹配项，则 instanceof 返回 false。
- 在每次循环中，如果未找到匹配，则将当前原型更新为其自身的 [[Prototype]]，继续向上查找。

值得注意的是，ES6 引入了 Symbol.hasInstance 属性，它允许构造函数自定义 instanceof 的行为。如果构造函数定义了 Symbol.hasInstance 方法，instanceof 会优先调用该方法来判断，而不是直接执行上述原型链遍历逻辑。我们将在后面详细讨论这一点。但在没有自定义 Symbol.hasInstance 的情况下，上述原型链遍历逻辑是其默认且核心的行为。

4. `instanceof` 的底层算法：沿着原型链的递归或迭代

现在，让我们通过模拟 instanceof 的行为，用 JavaScript 代码来实现一个 myInstanceof 函数，来更深入地理解其底层算法。我们将分别演示迭代版和递归版。

4.1 核心算法步骤分解

前置条件检查：
- 检查 object 是否为 null 或原始类型。如果是，直接返回 false。
- 检查 constructor 是否为函数。如果不是，抛出 TypeError。
- 获取 constructor 的 prototype 属性。检查它是否为对象。如果不是，抛出 TypeError。
获取起始原型：
- 从 object 的直接原型开始遍历。
循环遍历原型链：
- 在一个循环中，不断地向上获取当前原型的原型。
- 在每一步，将当前原型与 constructor.prototype 进行比较。
终止条件：
- 如果找到一个原型与 constructor.prototype 严格相等，则返回 true。
- 如果遍历到原型链的末端（即当前原型为 null），仍未找到匹配项，则返回 false。

4.2 `myInstanceof` 函数实现（迭代版）

迭代版是最常见的实现方式，因为它避免了递归可能带来的栈溢出问题，并且逻辑清晰。

/**
 * 模拟 instanceof 运算符的底层逻辑（迭代版）
 * 检查 object 是否是 constructor 的实例
 * @param {any} object 要检查的对象
 * @param {Function} constructor 构造函数
 * @returns {boolean} 如果 object 是 constructor 的实例，则返回 true，否则返回 false
 * @throws {TypeError} 如果 constructor 不是一个函数，或者其 prototype 属性不是一个对象
 */
function myInstanceof(object, constructor) {
    // 1. 前置条件检查：左操作数
    // 如果 object 是 null 或原始类型，它不能是任何构造函数的实例
    if (typeof object !== 'object' || object === null) {
        return false;
    }

    // 2. 前置条件检查：右操作数
    // constructor 必须是一个函数
    if (typeof constructor !== 'function') {
        throw new TypeError('Right-hand side of instanceof is not a function or callable object');
    }

    // 3. 获取 constructor 的原型对象
    // constructor.prototype 必须是一个对象，否则无法进行原型链比较
    const prototypeOfConstructor = constructor.prototype;
    if (typeof prototypeOfConstructor !== 'object' || prototypeOfConstructor === null) {
        throw new TypeError('The prototype property of the constructor is not an object or is null');
    }

    // 4. 获取 object 的直接原型，作为遍历的起点
    let currentProto = Object.getPrototypeOf(object);

    // 5. 循环遍历原型链
    // 只要 currentProto 不为 null，就沿着原型链向上查找
    while (currentProto !== null) {
        // 如果当前原型严格等于 constructor 的 prototype 属性，则找到了匹配
        if (currentProto === prototypeOfConstructor) {
            return true;
        }
        // 继续向上查找，获取当前原型的原型
        currentProto = Object.getPrototypeOf(currentProto);
    }

    // 6. 如果遍历完整个原型链都没有找到匹配，则返回 false
    return false;
}

// --- 测试用例 ---

// 基础类和继承
class Person {
    constructor(name) { this.name = name; }
}
class Student extends Person {
    constructor(name, id) { super(name); this.id = id; }
}

const student = new Student('Alice', 101);
const person = new Person('Bob');
const genericObj = {};
const arr = [1, 2, 3];
const func = function() {};
const num = 123;
const str = 'hello';
const bool = true;
const nulVal = null;
const undVal = undefined;

console.log('--- 自定义 myInstanceof 测试 ---');

// 实例及其自身构造函数
console.log(`myInstanceof(student, Student): ${myInstanceof(student, Student)}`);     // true
console.log(`myInstanceof(person, Person): ${myInstanceof(person, Person)}`);         // true

// 实例及其父类构造函数
console.log(`myInstanceof(student, Person): ${myInstanceof(student, Person)}`);       // true
console.log(`myInstanceof(student, Object): ${myInstanceof(student, Object)}`);       // true
console.log(`myInstanceof(arr, Array): ${myInstanceof(arr, Array)}`);                 // true
console.log(`myInstanceof(arr, Object): ${myInstanceof(arr, Object)}`);               // true

// 不相关的构造函数
console.log(`myInstanceof(student, Function): ${myInstanceof(student, Function)}`);   // false
console.log(`myInstanceof(genericObj, Student): ${myInstanceof(genericObj, Student)}`); // false

// 原始值和 null/undefined
console.log(`myInstanceof(num, Number): ${myInstanceof(num, Number)}`);               // false
console.log(`myInstanceof(str, String): ${myInstanceof(str, String)}`);               // false
console.log(`myInstanceof(bool, Boolean): ${myInstanceof(bool, Boolean)}`);           // false
console.log(`myInstanceof(nulVal, Object): ${myInstanceof(nulVal, Object)}`);         // false
console.log(`myInstanceof(undVal, Object): ${myInstanceof(undVal, Object)}`);         // false

// 包装对象
console.log(`myInstanceof(new Number(123), Number): ${myInstanceof(new Number(123), Number)}`); // true
console.log(`myInstanceof(new String('hi'), String): ${myInstanceof(new String('hi'), String)}`); // true

// 边界情况：右侧不是函数
try {
    myInstanceof({}, 123);
} catch (e) {
    console.log(`myInstanceof({}, 123) 抛出错误: ${e.message}`); // 抛出 TypeError
}

// 边界情况：构造函数没有有效的 prototype
function MyConstructorWithoutPrototype() {}
Object.defineProperty(MyConstructorWithoutPrototype, 'prototype', {
    value: null,
    writable: true,
    configurable: true
});
try {
    myInstanceof({}, MyConstructorWithoutPrototype);
} catch (e) {
    console.log(`myInstanceof({}, MyConstructorWithoutPrototype) 抛出错误: ${e.message}`); // 抛出 TypeError
}

4.3 `myInstanceof` 函数实现（递归版）

递归版实现虽然在实际应用中不如迭代版常用（主要是因为深层递归可能导致栈溢出），但它能更直观地体现“沿着原型链递归判断”的思想。

/**
 * 模拟 instanceof 运算符的底层逻辑（递归版）
 * 检查 object 是否是 constructor 的实例
 * @param {any} object 要检查的对象
 * @param {Function} constructor 构造函数
 * @returns {boolean} 如果 object 是 constructor 的实例，则返回 true，否则返回 false
 * @throws {TypeError} 如果 constructor 不是一个函数，或者其 prototype 属性不是一个对象
 */
function myInstanceofRecursive(object, constructor) {
    // 1. 前置条件检查（同迭代版）
    if (typeof object !== 'object' || object === null) {
        return false;
    }
    if (typeof constructor !== 'function') {
        throw new TypeError('Right-hand side of instanceof is not a function or callable object');
    }

    const prototypeOfConstructor = constructor.prototype;
    if (typeof prototypeOfConstructor !== 'object' || prototypeOfConstructor === null) {
        throw new TypeError('The prototype property of the constructor is not an object or is null');
    }

    // 2. 内部递归函数
    function checkChain(currentProto) {
        // 递归终止条件1: 到达原型链末端
        if (currentProto === null) {
            return false;
        }
        // 递归终止条件2: 找到匹配
        if (currentProto === prototypeOfConstructor) {
            return true;
        }
        // 递归调用，检查当前原型的原型
        return checkChain(Object.getPrototypeOf(currentProto));
    }

    // 3. 从 object 的直接原型开始递归检查
    return checkChain(Object.getPrototypeOf(object));
}

// --- 测试用例 (与迭代版结果相同) ---
console.log('n--- 自定义 myInstanceofRecursive 测试 ---');
const studentRecursive = new Student('Charlie', 102);
console.log(`myInstanceofRecursive(studentRecursive, Student): ${myInstanceofRecursive(studentRecursive, Student)}`); // true
console.log(`myInstanceofRecursive(studentRecursive, Person): ${myInstanceofRecursive(studentRecursive, Person)}`);   // true
console.log(`myInstanceofRecursive(null, Object): ${myInstanceofRecursive(null, Object)}`);       // false

通过这两种实现，我们可以清晰地看到 instanceof 的核心机制：它就是沿着对象的 [[Prototype]] 链，逐级向上查找，直到找到与 constructor.prototype 严格相等的原型对象，或者到达链的顶端 null。

5. ES6 Class 与 `instanceof`

ES6 引入的 class 语法糖，为 JavaScript 中的面向对象编程提供了更清晰、更易读的方式。尽管语法有所改变，但其底层仍然是基于构造函数和原型链的。因此，instanceof 运算符对 ES6 class 同样适用，其工作原理没有改变。

class Vehicle {
    constructor(name) {
        this.name = name;
    }
    drive() { console.log(`${this.name} is driving.`); }
}

class Car extends Vehicle {
    constructor(name, brand) {
        super(name);
        this.brand = brand;
    }
    honk() { console.log('Beep beep!'); }
}

const myCar = new Car("Model S", "Tesla");

console.log(myCar instanceof Car);     // true
console.log(myCar instanceof Vehicle); // true
console.log(myCar instanceof Object);  // true
console.log(myCar instanceof Function); // false (myCar 是对象，不是函数)

这再次证明了 class 只是原型继承的一种更现代的写法，instanceof 依然能正确地通过原型链追溯实例的类型。

6. `instanceof` 的局限性与陷阱

尽管 instanceof 是一个强大的工具，但它并非完美无缺。在使用时，我们需要了解它的局限性和可能遇到的陷阱。

6.1 跨 Realm (iframe/Web Worker) 问题

JavaScript 存在“Realm”的概念，每个 Realm 都有自己独立的全局对象、内置构造函数和原型链。例如，一个网页的主窗口、一个 <iframe> 内部、或者一个 Web Worker，它们都属于不同的 Realm。

这意味着，在一个 Realm 中创建的对象，如果尝试用另一个 Realm 的构造函数来判断其类型，instanceof 可能会返回 false。这是因为即使它们看起来是同一个类型，它们的 constructor.prototype 也是来自不同的 Realm，因此在内存中是不同的对象，无法通过 === 比较。

// 假设这是在主页面环境中运行的代码
const iframe = document.createElement('iframe');
document.body.appendChild(iframe);
const iframeWindow = iframe.contentWindow;

// 在 iframe 中创建一个数组
const arrInIframe = new iframeWindow.Array(1, 2, 3);

// 使用主页面的 Array 构造函数来检查
console.log(arrInIframe instanceof Array); // 预期输出: false
// 解释: arrInIframe 的原型链中包含 iframeWindow.Array.prototype，
// 但不包含主页面的 Array.prototype，因为它们是两个不同的对象。

// 使用 iframe 内部的 Array 构造函数来检查
console.log(arrInIframe instanceof iframeWindow.Array); // 预期输出: true

// 清理 iframe
document.body.removeChild(iframe);

这种情况下，Object.prototype.toString.call() 通常是更可靠的解决方案，因为它返回的是字符串，不受 Realm 限制。

console.log(Object.prototype.toString.call(arrInIframe)); // "[object Array]"

6.2 `constructor` 的 `prototype` 属性被修改

instanceof 依赖于 constructor.prototype 属性。如果这个属性在运行时被意外或恶意地修改，instanceof 的结果就会变得不可预测。

function Foo() {}
const f1 = new Foo();
console.log(f1 instanceof Foo); // true (f1 的 [[Prototype]] 指向 Foo.prototype)

// 此时 Foo.prototype 是一个对象，我们将其替换为另一个对象
Foo.prototype = {
    // 通常这里还会设置 constructor 属性指向 Foo，但为了演示，我们省略
    method: function() { console.log('new method'); }
};

const f2 = new Foo();
console.log(f2 instanceof Foo); // true (f2 的 [[Prototype]] 指向新的 Foo.prototype)

// 重要的点：f1 的原型链并没有改变，它仍然指向旧的 Foo.prototype
console.log(f1 instanceof Foo); // false! 因为 f1 的原型链中不再包含当前 Foo.prototype

这种行为虽然是符合 instanceof 定义的，但在不清楚 prototype 是否被修改的情况下，可能会导致意料之外的结果。

6.3 `Symbol.hasInstance` 属性：改变 `instanceof` 行为的钩子

ES6 引入了一个特殊的 Symbol 值 Symbol.hasInstance。如果一个构造函数（或类）定义了 Symbol.hasInstance 方法，那么当 instanceof 运算符被调用时，它会优先调用 constructor[Symbol.hasInstance](object) 方法来判断，而不是执行默认的原型链遍历逻辑。

这为 instanceof 提供了极大的灵活性，允许我们完全自定义类型判断的逻辑，使其不再局限于原型链。

class MyCustomChecker {
    // 定义 Symbol.hasInstance 方法
    static [Symbol.hasInstance](instance) {
        console.log(`Custom check for: ${instance}`);
        // 假设我们认为任何以 'prefix-' 开头的字符串都是 MyCustomChecker 的实例
        return typeof instance === 'string' && instance.startsWith('prefix-');
    }
}

console.log('prefix-hello' instanceof MyCustomChecker); // true (调用了自定义逻辑)
console.log('hello world' instanceof MyCustomChecker); // false
console.log(123 instanceof MyCustomChecker);         // false
console.log(new Date() instanceof MyCustomChecker);  // false

// 如果没有定义 Symbol.hasInstance，它就会回退到原型链检查
class AnotherClass {}
const obj = new AnotherClass();
console.log(obj instanceof AnotherClass); // true (回退到原型链检查)

Symbol.hasInstance 使得 instanceof 的行为变得更加复杂和强大。在面对自定义 instanceof 逻辑的场景时，我们不能仅仅依靠原型链的知识来判断，还需要考虑 Symbol.hasInstance 的存在。

7. 其他类型判断方法及其与 `instanceof` 的比较

JavaScript 提供了多种类型判断方法，每种都有其适用场景和局限性。了解它们之间的差异，有助于我们选择最合适的工具。

7.1 `typeof` 运算符

作用：用于判断原始类型（string, number, boolean, symbol, bigint, undefined）和 function。
局限性：
- 对于所有对象（除了函数），typeof 都返回 "object"，无法区分数组、日期、正则、普通对象等。
- typeof null 返回 "object"，这是一个历史遗留的 bug。

console.log(typeof "hello");       // "string"
console.log(typeof 123);           // "number"
console.log(typeof true);          // "boolean"
console.log(typeof undefined);     // "undefined"
console.log(typeof Symbol('id'));  // "symbol"
console.log(typeof 10n);           // "bigint"
console.log(typeof function(){});  // "function"
console.log(typeof {});            // "object"
console.log(typeof []);            // "object"
console.log(typeof null);          // "object" (注意这个特例)

typeof 适用于快速判断基本类型，但对于对象类型的细致区分则力不从心。

7.2 `Object.prototype.toString.call()`

作用：这是 JavaScript 中最准确、最通用的类型判断方法之一。它返回一个格式为 "[object Type]" 的字符串，其中 Type 是对象的内部 [[Class]] 属性值。
优点：
- 可以准确区分所有内置对象类型，如 Array, Date, RegExp, Function, Error 等。
- 甚至可以区分 null ("[object Null]") 和 undefined ("[object Undefined]")。
- 跨 Realm 安全：因为返回的是字符串，所以不受不同 Realm 中构造函数实例化的影响。

console.log(Object.prototype.toString.call("hello"));       // "[object String]"
console.log(Object.prototype.toString.call(123));           // "[object Number]"
console.log(Object.prototype.toString.call(true));          // "[object Boolean]"
console.log(Object.prototype.toString.call(undefined));     // "[object Undefined]"
console.log(Object.prototype.toString.call(null));          // "[object Null]"
console.log(Object.prototype.toString.call({}));            // "[object Object]"
console.log(Object.prototype.toString.call([]));            // "[object Array]"
console.log(Object.prototype.toString.call(new Date()));    // "[object Date]"
console.log(Object.prototype.toString.call(function(){}));  // "[object Function]"
console.log(Object.prototype.toString.call(/regex/));       // "[object RegExp]"

此方法非常适合需要精确区分内置类型的场景，尤其是考虑到跨 Realm 的兼容性。

7.3 `constructor` 属性

作用：每个对象通常都有一个 constructor 属性，它指向创建该实例的构造函数。
用法：obj.constructor === SomeClass
局限性：
- constructor 属性是可写的，容易被覆盖或修改，导致判断不准确。
- 在继承链中，子类实例的 constructor 属性默认指向子类构造函数，而不是父类构造函数。因此，它不能像 instanceof 那样检查整个继承链。
- 对于通过对象字面量 {} 或数组字面量 [] 创建的对象，它们的 constructor 属性分别指向 Object 和 Array。

class Parent {}
class Child extends Parent {}
const c = new Child();

console.log(c.constructor === Child);  // true
console.log(c.constructor === Parent); // false (即使 c 是 Parent 的实例，但 constructor 指向 Child)

const obj = {};
console.log(obj.constructor === Object); // true

function Foo() {}
const f = new Foo();
Foo.prototype.constructor = "oops"; // 恶意或意外修改 constructor 属性
console.log(f.constructor); // "oops" - 此时 f.constructor 不再是 Foo

由于其易变性和继承判断的局限性，constructor 属性通常不被推荐作为可靠的类型判断方法。

7.4 类型判断方法对比总结

方法	优点	缺点	适用场景
`instanceof`	检查原型链，适用于判断对象是否为某个构造函数或其子类的实例，支持继承	跨 Realm 失效，`Symbol.hasInstance` 可修改行为，依赖 `prototype` 属性	判断对象是否是某个特定构造函数或其子类的实例
`typeof`	简单，性能高，判断基本类型和函数	无法区分所有对象类型 (`"object"`)，`null` 的误报	快速判断基本类型，或明确是否是函数
`Object.prototype.toString.call()`	最准确，可区分所有内置类型，包括 `null`/`undefined`，跨 Realm 安全	返回字符串，需要额外处理，代码稍显冗长	区分内置对象类型（数组、日期、正则等），跨 Realm 安全
`obj.constructor === Ctor`	直观	`constructor` 属性可被修改/覆盖，继承关系判断不准确	简单判断对象是否由特定构造函数直接创建（但需谨慎）
`Symbol.hasInstance`	高度自定义 `instanceof` 行为	增加了判断的复杂性和不透明性，需要理解其机制	需要自定义类型判断逻辑的复杂场景，例如实现“鸭子类型”检查

8. 深入 `Symbol.hasInstance`

为了更完整地理解 instanceof，我们有必要再次强调 Symbol.hasInstance 的作用。在 ECMAScript 规范中，instanceof 运算符的执行流程是这样的：

检查 constructor 是否定义了 Symbol.hasInstance 方法。
如果定义了：调用 constructor[Symbol.hasInstance](object)，并直接返回其结果。此时，原型链的遍历逻辑被完全绕过。
如果未定义：回退到标准的 OrdinaryHasInstance 抽象操作，即我们前面详细讲解的原型链遍历算法。

这意味着，instanceof 并非总是严格遵循原型链检查。它首先是一个“询问”构造函数自身如何判断实例的机制。只有当构造函数没有提供自定义的判断方式时，它才会默认采用原型链检查。

这个机制使得 JavaScript 中的类型判断更加灵活。例如，Function 构造函数本身就实现了 Symbol.hasInstance，这使得 function() {} instanceof Function 能够正确返回 true。而对于我们自己定义的 class，可以通过 static [Symbol.hasInstance](instance) { ... } 来为它添加自定义的 instanceof 行为。

理解 Symbol.hasInstance 是理解现代 JavaScript 中 instanceof 运算符的完整画像的关键。它将 instanceof 从一个纯粹的原型链检查器，提升为一个可自定义的类型验证工具。

9. `instanceof` 的性能考量

在大多数日常应用中，instanceof 运算符的性能开销通常可以忽略不计。JavaScript 引擎对 instanceof 进行了高度优化，原型链的遍历深度在实际场景中也通常是有限的。

只有在极少数极端情况下，例如在一个性能关键的紧密循环中，对具有非常深（成百上千层）原型链的对象进行极其频繁的 instanceof 检查时，才可能需要考虑其性能影响。但在绝大多数情况下，我们无需为此担忧。相比于代码的清晰性、准确性和可维护性，instanceof 的微小性能差异通常不是决定性的因素。

10. 理解 `instanceof`：深入JavaScript运行时

instanceof 运算符不仅仅是一个简单的类型检查工具，它更是理解 JavaScript 面向对象编程和继承机制的窗口。通过深入其底层算法，我们不仅掌握了如何判断对象类型，更重要的是，我们加深了对：

原型与原型链：对象如何通过 [[Prototype]] 链接起来，形成继承关系。
构造函数与实例：new 运算符如何关联构造函数的 prototype 和实例的 [[Prototype]]。
ES6 Class 的本质：它只是原型继承的语法糖，并未改变底层机制。
现代 JavaScript 的灵活性：Symbol.hasInstance 如何允许我们自定义语言行为。

这些都是 JavaScript 运行时中至关重要的概念。掌握 instanceof 的工作原理，将有助于我们编写更健壮、更可预测的代码，并在遇到类型相关的 Bug 时，能够更有效地进行分析和调试。

11. 深入理解，精确判断

instanceof 运算符的核心是沿着对象的原型链向上查找，直到找到与构造函数的 prototype 属性严格相等的原型对象，或者到达原型链的末端。其行为可以通过 Symbol.hasInstance 属性进行自定义，为类型判断提供了强大的灵活性。在选择类型判断方法时，应根据具体场景权衡 instanceof、typeof 和 Object.prototype.toString.call() 的优缺点，以确保代码的健壮性和准确性。

1. 引言：类型判断的基石与 instanceof 的魅力

2. JavaScript 原型机制：一切的根源

2.1 什么是原型 (Prototype)？

2.2 原型链 (Prototype Chain)

2.3 构造函数与原型

3. instanceof 运算符的精确定义

4. instanceof 的底层算法：沿着原型链的递归或迭代

4.1 核心算法步骤分解

4.2 myInstanceof 函数实现（迭代版）

4.3 myInstanceof 函数实现（递归版）

5. ES6 Class 与 instanceof

6. instanceof 的局限性与陷阱

6.1 跨 Realm (iframe/Web Worker) 问题

6.2 constructor 的 prototype 属性被修改

6.3 Symbol.hasInstance 属性：改变 instanceof 行为的钩子

7. 其他类型判断方法及其与 instanceof 的比较

7.1 typeof 运算符

7.2 Object.prototype.toString.call()

7.3 constructor 属性