JavaScript自定义@@hasInstance方法详解

深入解析 JavaScript 自定义 @@hasInstance 的奥秘：避免常见陷阱，提升代码健壮性 在 JavaScript 中，自定义 @@hasInstance 方法能够赋予 instanceof 运算符更灵活的类型判断能力。然而，直接赋值 `Foo[Symbol.hasInstance] = ...` 往往无法生效，这源于 `Function.prototype` 上 `Symbol.hasInstance` 属性的只读特性。本文剖析了原型链中只读属性对赋值操作的影响，并提供了两种正确定义自定义 @@hasInstance 的方法：利用 `Object.defineProperty()` 精确控制属性特性，以及在 ES6 类中使用 `static` 关键字声明静态方法。掌握这些技巧，确保 instanceof 运算符按预期工作，编写更健壮、易于理解的 JavaScript 代码。

本文深入探讨了在 JavaScript 中自定义 @@hasInstance 方法时常见的陷阱。我们揭示了直接通过赋值操作 Foo[Symbol.hasInstance] = ... 无法生效的根本原因，即 Function.prototype 上 Symbol.hasInstance 属性的只读特性。文章详细阐述了原型链中只读属性对赋值操作的影响，并提供了使用 Object.defineProperty() 或 static 类方法正确定义自定义 @@hasInstance 的专业指导，确保 instanceof 运算符按预期工作。

理解 Symbol.hasInstance 的作用

Symbol.hasInstance 是 JavaScript 中的一个知名符号（Well-Known Symbol），它定义了 instanceof 运算符的行为。当我们执行 instance instanceof Constructor 时，JavaScript 实际上会调用 Constructor[Symbol.hasInstance](instance) 方法。通过自定义这个方法，我们可以改变 instanceof 的默认逻辑，使其能够识别非传统意义上的“实例”。

例如，一个类或构造函数可以定义自己的 @@hasInstance 方法，以判断一个对象是否是它的一个“实例”，即使这个对象并非通过该构造函数直接创建。

class MyClass {
  static [Symbol.hasInstance](obj) {
    // 自定义判断逻辑
    return typeof obj === 'string' && obj.startsWith('my-');
  }
}

console.log('my-instance' instanceof MyClass); // true
console.log('another-instance' instanceof MyClass); // true
console.log('not-my-instance' instanceof MyClass); // false
console.log({} instanceof MyClass); // false

直接赋值 Foo[Symbol.hasInstance] = ... 为什么会失败？

在尝试为函数或类自定义 Symbol.hasInstance 时，开发者可能会直观地尝试使用直接赋值的方式，例如：

function Foo() {}
Foo[Symbol.hasInstance] = function(instance) {
  return false;
};

console.dir(Foo); // 似乎没有显示该属性
console.log(Object.hasOwn(Foo, Symbol.hasInstance)); // false
console.log(Foo[Symbol.hasInstance] === Function.prototype[Symbol.hasInstance]); // true

上述代码尝试为 Foo 函数添加一个 Symbol.hasInstance 属性，但实际上该属性并未成功创建为 Foo 的自有属性。这背后的原因与 JavaScript 的原型链和属性特性密切相关。

原型链中的只读属性冲突

所有函数在 JavaScript 中都是 Function 的实例，因此它们的原型链上都继承自 Function.prototype。Function.prototype 对象上默认就存在一个 Symbol.hasInstance 属性，并且这个属性是只读的（writable: false）。

我们可以通过 Object.getOwnPropertyDescriptor 来验证这一点：

const descriptor = Object.getOwnPropertyDescriptor(Function.prototype, Symbol.hasInstance);
console.log(descriptor);
/*
{
  "value": function [Symbol.hasInstance]() { [native code] },
  "writable": false, // 关键：此属性是只读的
  "enumerable": false,
  "configurable": false
}
*/

当尝试通过直接赋值 (=) 为一个对象设置属性时，如果该属性在原型链上已经存在且是只读的，JavaScript 的默认行为是不会在当前对象上创建同名自有属性来覆盖它。相反，赋值操作会被默默地忽略（在非严格模式下），或者在严格模式下抛出 TypeError。

考虑以下示例，它模拟了同样的原型链只读属性问题：

const myPrototype = Object.create(null, {
  x: {
    value: 1,
    writable: false // 定义一个只读属性
  }
});

const obj = Object.create(myPrototype); // obj 的原型是 myPrototype

obj.x = 2; // 尝试为 obj 创建一个名为 'x' 的自有属性
console.log(obj.x); // 输出仍然是 1
console.log(Object.hasOwn(obj, 'x')); // false

在这个例子中，尽管我们尝试将 obj.x 设置为 2，但由于 obj 的原型 myPrototype 上存在一个只读的 x 属性，这个赋值操作未能成功在 obj 上创建自有属性，因此 obj.x 仍然访问到原型链上的 x 属性，其值为 1。

在严格模式下，这种尝试会直接抛出错误：

"use strict";
function FooStrict() {}
try {
  FooStrict[Symbol.hasInstance] = function(instance) { return false };
} catch (e) {
  console.error(e.message); // Uncaught TypeError: Cannot assign to read only property '[Symbol.hasInstance]' of object 'function FooStrict() {}'
}

这明确指出了问题所在：我们不能对一个只读属性进行赋值。

正确定义自定义 @@hasInstance 方法

为了正确地定义自定义 @@hasInstance 方法，我们需要避免直接赋值的限制，使用能够直接在目标对象上创建或修改属性的机制。

方法一：使用 Object.defineProperty()

Object.defineProperty() 方法允许我们精确地定义一个对象的自有属性，包括其值、可写性、可枚举性和可配置性。它不会像直接赋值那样遍历原型链来检查只读属性，而是直接尝试在目标对象上创建或修改属性。

function Foo() {}

Object.defineProperty(Foo, Symbol.hasInstance, {
  value(instance) {
    // 假设 Foo 的实例是所有数字
    return typeof instance === 'number';
  },
  writable: false, // 建议设置为 false，保持与 Function.prototype 的行为一致
  enumerable: false,
  configurable: true, // 允许后续修改或删除
});

console.log(Object.hasOwn(Foo, Symbol.hasInstance)); // true
console.log(123 instanceof Foo); // true
console.log('hello' instanceof Foo); // false
console.log(Foo[Symbol.hasInstance] === Function.prototype[Symbol.hasInstance]); // false

通过 Object.defineProperty()，我们成功地在 Foo 对象上创建了 Symbol.hasInstance 这个自有属性，并覆盖了原型链上的默认行为。

方法二：在 Class 中使用 static 关键字

对于 ES6 的类（class），定义 @@hasInstance 方法的最简洁和推荐的方式是使用 static 关键字。类中的静态方法直接作为类的属性存在，而不是其原型链上的属性。

class MyCustomClass {
  static [Symbol.hasInstance](obj) {
    // 自定义逻辑：判断 obj 是否为数组
    return Array.isArray(obj);
  }
}

console.log([] instanceof MyCustomClass); // true
console.log([1, 2, 3] instanceof MyCustomClass); // true
console.log({} instanceof MyCustomClass); // false
console.log('string' instanceof MyCustomClass); // false

这种方式同样避免了与 Function.prototype 上只读 Symbol.hasInstance 属性的冲突，因为它直接在 MyCustomClass 这个构造函数对象上定义了静态属性。

为什么 Symbol.iterator 可以直接赋值？

为了进一步理解 Symbol.hasInstance 的特殊性，我们可以对比 Symbol.iterator。在原始问题中提到，直接赋值 Foo[Symbol.iterator] = ... 是可以正常工作的：

function FooIterator() {}
FooIterator[Symbol.iterator] = function() {
  let count = 0;
  return {
    next() {
      if (count < 3) {
        return { value: count++, done: false };
      }
      return { value: undefined, done: true };
    }
  };
};

console.dir(FooIterator); // 会显示 Symbol.iterator 属性
console.log(Object.hasOwn(FooIterator, Symbol.iterator)); // true

for (const val of FooIterator) {
  console.log(val); // 0, 1, 2
}

这是因为 Function.prototype 上并没有定义 Symbol.iterator 属性。因此，当尝试通过直接赋值为 FooIterator 添加 Symbol.iterator 属性时，原型链上没有只读属性的冲突，赋值操作会成功地在 FooIterator 对象上创建这个自有属性。

总结与最佳实践

• 核心问题：直接赋值 Foo[Symbol.hasInstance] = ... 失败的原因是 Function.prototype 上存在一个只读的 Symbol.hasInstance 属性，直接赋值无法覆盖原型链上的只读属性。
• 解决方案：
  • 对于函数构造器，使用 Object.defineProperty(Constructor, Symbol.hasInstance, { value: ..., writable: false, enumerable: false, configurable: true }) 来定义。
  • 对于 ES6 类，使用 static [Symbol.hasInstance](obj) { ... } 语法。
• 注意事项：
  • 在定义 Symbol.hasInstance 时，通常建议将其 writable 特性设置为 false，以保持与 Function.prototype 的一致性，并防止意外修改。
  • Symbol.hasInstance 是一个强大的特性，可以用于创建自定义的类型检查逻辑，但应谨慎使用，确保其行为符合预期，避免引入难以理解的隐式逻辑。

理解 JavaScript 原型链和属性特性的细节对于编写健壮和可预测的代码至关重要。特别是对于像 Symbol.hasInstance 这样与核心语言行为紧密相关的知名符号，遵循正确的定义方式是确保代码按预期运行的关键。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《JavaScript自定义@@hasInstance方法详解》文章吧，也可关注golang学习网公众号了解相关技术文章。