使用 reflect 判断继承关系的核心方法是调用 reflect.getprototypeof() 获取目标对象的原型，然后将其与构造函数的原型链进行比对。具体做法是提取实例的 [[prototype]]，检查它是否等于父类的 prototype 属性，或者在遍历原型链时匹配特定的类名。这样做可以准确识别对象的直接继承来源，而不会受到 instanceof 在多全局环境（如 iframe）下失效的影响。
如何判断一个对象是否是另一个类的直接子类
要判断对象 obj 是否是类 Parent 的直接实例，需要比较 obj 的原型与 Parent.prototype 是否严格相等。如果两者指向同一个对象引用，则说明 obj 直接继承了 Parent。这种方法比 obj instanceof Parent 更可靠，因为它只检查单一层级的原型链，不涉及跨框架或跨窗口的原型隔离问题。
class Parent {
constructor() { this.type = 'parent'; }
}
class Child extends Parent {
constructor() { super(); this.type = 'child'; }
}
const instance = new Child();
// 使用 Reflect 获取原型
const proto = Reflect.getPrototypeOf(instance);
// 判断是否为直接子类
console.log(proto === Parent.prototype); // true
console.log(proto.constructor.name); // "Child"
运行上述代码，Reflect.getPrototypeOf(instance) 返回的是 Child.prototype。通过 === 运算符对比 Parent.prototype，结果为 true，确认了直接继承关系。同时，可以通过 constructor.name 获取当前原型的构造函数名称，进一步验证层级。
如何遍历原型链以查找特定父类
当需要判断对象是否间接继承了某个类（即该类位于原型链的更上层）时，可以使用 while 循环配合 Reflect.getPrototypeOf() 逐层向上查找。从实例的原型开始，依次获取上一层原型，直到找到目标类或到达 null。这种方式能够处理多层继承结构，确保无论继承深度如何，都能准确定位到指定的父类。
class GrandParent {
constructor() { this.level = 'grandparent'; }
}
class Parent extends GrandParent {
constructor() { super(); this.level = 'parent'; }
}
class Child extends Parent {
constructor() { super(); this.level = 'child'; }
}
const instance = new Child();
function isInstanceOf(obj, targetClass) {
let currentProto = Reflect.getPrototypeOf(obj);
while (currentProto !== null) {
if (currentProto === targetClass.prototype) {
return true;
}
currentProto = Reflect.getPrototypeOf(currentProto);
}
return false;
}
console.log(isInstanceOf(instance, GrandParent)); // true
console.log(isInstanceOf(instance, Parent)); // true
console.log(isInstanceOf(instance, Object)); // true
执行这段代码，isInstanceOf 函数会遍历 Child 实例的原型链：Child.prototype -> Parent.prototype -> GrandParent.prototype -> Object.prototype -> null。在每一步中，都会检查当前原型是否与目标类的 prototype 相等。对于 GrandParent、Parent 和 Object，函数均返回 true，证明了该方法能有效检测任意层级的继承关系。
基于输入条件判断原型链断裂的情况
如果在代码中手动修改了原型链，例如将 Child.prototype 设置为一个普通对象而非 Parent.prototype 的实例，会导致继承关系断裂。此时，Reflect.getPrototypeOf() 仍然能获取到当前的原型对象，但该原型不再包含父类的特征方法或属性。这种操作会破坏标准的继承机制，导致类型检查失败。
class Parent {
greet() { return 'Hello'; }
}
class Child extends Parent {}
// 正常情况
console.log(Reflect.getPrototypeOf(new Child()) === Parent.prototype); // true
// 异常修改：手动替换原型
Child.prototype = { customMethod: () => 'Custom' };
// 再次检查
const modifiedInstance = new Child();
console.log(Reflect.getPrototypeOf(modifiedInstance) === Parent.prototype); // false
console.log(Reflect.getPrototypeOf(modifiedInstance).customMethod()); // "Custom"
console.log(modifiedInstance.greet()); // undefined
在上述示例中，首先创建了一个正常的 Child 实例，其原型链正确指向 Parent.prototype。随后，我们将 Child.prototype 重新赋值为一个新的普通对象。此时，新创建的 modifiedInstance 的原型变成了这个新对象，而不是 Parent.prototype。因此，Reflect.getPrototypeOf(modifiedInstance) === Parent.prototype 返回 false，且实例无法访问 greet 方法，因为 greet 定义在 Parent.prototype 上，而新的原型链中不包含它。这展示了手动干预原型链对继承判断的影响。
Java免费学习笔记：立即使用
解锁 Java 大师之旅：从入门到精通的终极指南
