理解 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 的原型链和属性特性密切相关。
立即学习“Java免费学习笔记（深入）”；
原型链中的只读属性冲突
所有函数在 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 这样与核心语言行为紧密相关的知名符号，遵循正确的定义方式是确保代码按预期运行的关键。
