JavaScript Proxy getPrototypeOf-代码号

JavaScript Proxy 的 getPrototypeOf ：原型链的精确控制

在 JavaScript 的 Proxy 机制中，getPrototypeOf 是一个专门用于拦截原型链读取操作的核心方法。当我们使用 Object.getPrototypeOf()、obj.__proto__、instanceof 或者原型链继承相关的操作时，这个就会被触发。理解它的工作原理，对于掌控对象的原型行为非常重要。

什么是 getPrototypeOf ？

简单来说，这个让我们能够“重新定义”一个对象的原型。当代码试图获取某个代理对象的原型时，我们定义的 getPrototypeOf 方执行，而不是直接返回目标对象的原型。

的语法结构：

const handler = {
    getPrototypeOf: function(target) {
        // target: 被代理的原始对象
        // 返回值: 必须是一个对象或者 null
    }
};

参数解析：

target：这是被代理的原始对象，而不是代理对象本身。我们可以在内部基于这个目标对象进行判断和处理。

返回值：
这个必须返回一个对象（通常是某个原型对象）或者 null。如果返回其他类型的值，JavaScript 引擎会抛出 TypeError。

核心约束规则

在使用 getPrototypeOf 时，有一个关键的约束需要特别注意。如果目标对象是不可扩展的（Object.isExtensible(target) === false），那么返回的值必须与 Object.getPrototypeOf(target) 一致。换句话说，当目标对象被锁定时，我们就不能再伪造原型了。

从基础示例开始理解

我们从一个最简单的例子入手，看看这个是如何拦截原型读取的。

示例 1：基础拦截与返回值验证

在这个例子中，我们演示了内部参数和 this 指向的情况。

// 代码号：learning-proxy-prototype-01
const targetObj = {};
const customProto = {};
const handler = {
    getPrototypeOf(target) {
        console.log('目标对象是否为 targetObj:', target === targetObj);
        console.log('当前 this 是否指向 handler:', this === handler);
        // 返回一个自定义的原型对象
        return customProto;
    }
};
const proxyInstance = new Proxy(targetObj, handler);

// 调用 Object.getPrototypeOf 会触发我们的
const result = Object.getPrototypeOf(proxyInstance);
console.log('获取到的原型是否为 customProto:', result === customProto);

个人经验： 在开发中，我经常在 getPrototypeOf 里添加日志，用来调试复杂的继承关系。当你发现 instanceof 的行为不符合预期，或者某个对象的原型链“断掉”了，不妨先检查一下这个是否被意外触发。

动态修改原型链：改变 instanceof 的行为

getPrototypeOf 最典型的应用场景之一，就是改变 instanceof 操作符的判断结果。因为 instanceof 本质上就是在遍历对象的原型链。

示例 2：让普通对象伪装成数组

这里我们让一个普通的对象实例，在被检查时表现出数组的特征。

// 代码号：learning-proxy-prototype-02
const plainObject = { name: "普通对象" };
const proxyObject = new Proxy(plainObject, {
    getPrototypeOf(target) {
        // 让该对象的原型指向 Array.prototype
        return Array.prototype;
    }
});

console.log(proxyObject instanceof Array);  // 输出: true
console.log(proxyObject instanceof Object); // 输出: true（因为 Array.prototype 的原型是 Object.prototype）

// 验证原始对象不受影响
console.log(plainObject instanceof Array); // 输出: false

为什么不用直接修改原型，而要用？
如果直接修改 plainObject.__proto__ 或使用 Object.setPrototypeOf()，会长久性地改变对象的原型结构。而使用 getPrototypeOf ，我们可以在不破坏原始对象的情况下，为外部调用者提供一个“虚拟”的原型视图。这对于需要兼容旧代码，或者实现某些特殊的沙箱环境非常有用。

动态返回不同的原型

我们可以根据某些条件，动态决定返回哪个原型对象，这为实现更灵活的对象行为提供了可能。

示例 3：根据属性值动态决定原型

假设我们想让对象根据某个标识符的不同，表现出不同的类型特征。

// 代码号：learning-proxy-prototype-03
const baseData = {
    type: "admin",
    name: "系统管理员"
};

const adminProto = {
    role: "administrator",
    getPermissions() {
        return ["read", "write", "delete"];
    }
};

const userProto = {
    role: "user",
    getPermissions() {
        return ["read"];
    }
};

const dynamicProxy = new Proxy(baseData, {
    getPrototypeOf(target) {
        // 根据 type 属性的值动态返回原型
        if (target.type === "admin") {
            return adminProto;
        }
        return userProto;
    }
});

console.log(Object.getPrototypeOf(dynamicProxy) === adminProto); // 输出: true
console.log(dynamicProxy.getPermissions()); // 输出: ["read", "write", "delete"]

不可扩展对象的严格限制

前面提到的约束规则在编码中非常重要。当目标对象被冻结或设置为不可扩展时，getPrototypeOf 就不能再随意返回其他值了。

示例 4：不可扩展对象下的行为

// 代码号：learning-proxy-prototype-04
const sealedTarget = {};
const originalProto = Object.getPrototypeOf(sealedTarget);
Object.preventExtensions(sealedTarget); // 将对象设置为不可扩展

const proxy = new Proxy(sealedTarget, {
    getPrototypeOf(target) {
        // 尝试返回一个不同的原型
        return { custom: true };
    }
});

// 这里会抛出 TypeError，因为 target 不可扩展且返回的原型与原原型不一致
try {
    Object.getPrototypeOf(proxy);
} catch (e) {
    console.log(e.message); // 输出: 'getPrototypeOf' on proxy: trap returned neither null nor the target's prototype
}

// 正确的做法：返回与原始原型一致的值
const correctProxy = new Proxy(sealedTarget, {
    getPrototypeOf(target) {
        return originalProto; // 返回原生的原型
    }
});
console.log(Object.getPrototypeOf(correctProxy) === originalProto); // 输出: true

本节课程知识要点：

返回值类型严格：必须返回对象或 null，不能返回其他基本类型。
不可扩展约束：当目标对象不可扩展时，的返回值必须与 Object.getPrototypeOf(target) 一致。
内部方法对应：getPrototypeOf 对应 [[GetPrototypeOf]] 内部方法，影响 Object.getPrototypeOf、__proto__ 和 instanceof。
反射 API 配合：在复杂场景中，可以使用 Reflect.getPrototypeOf(target) 来获取原始原型，然后进行判断或修饰。

结合 Reflect API 的实践

在真实的项目中，我们经常需要基于原始原型进行扩展，而不是覆盖。这时使用 Reflect API 会更加优雅。

// 代码号：learning-proxy-prototype-05
const originalObject = { value: 42 };
const extensionProto = { extra: "扩展功能" };

const proxy = new Proxy(originalObject, {
    getPrototypeOf(target) {
        // 先获取原始原型
        const original = Reflect.getPrototypeOf(target);
        // 如果原始原型存在，我们可以在其基础上添加一层包装
        if (original) {
            return extensionProto;
        }
        return original;
    }
});

console.log(Object.getPrototypeOf(proxy) === extensionProto); // 输出: true

个人建议： 当需要在 getPrototypeOf 中进行复杂逻辑判断时，优先使用 Reflect.getPrototypeOf(target) 来获取原始原型。这样做不仅能保持代码语义清晰，还能避免直接调用 Object.getPrototypeOf 时可能出现的 this 绑定问题。Reflect API 的设计初衷就是与 Proxy 的一一对应，让代码更易于理解和维护。

getPrototypeOf 是 JavaScript Proxy 体系中专门用于原型链操作的拦截器。它让我们能够动态控制对象的原型行为，实现类似“类型伪装”、“动态继承”等高级功能。理解它的返回值约束，特别是与目标对象可扩展性相关的限制，是正确使用这个的关键。在开发中，合理运用这个可以帮助我们构建更灵活、更安全的代码架构，尤其是在需要隔离对象行为或者实现复杂继承关系的场景下。

本文标签：

JavaScript Proxy getPrototypeOf