判断两个javascript对象是否拥有相同原型的最直接且推荐方式是使用 object.getprototypeof(obj1) === object.getprototypeof(obj2)；2. 该方法通过获取对象的内部[[prototype]]引用并进行严格相等比较，确保结果准确可靠；3. object.getprototypeof() 是标准方法，语义明确且不受对象属性干扰，而 proto 因非标准、可被覆盖及性能问题不推荐在生产环境中使用；4. instanceof 不适合判断直接原型相同，因为它检查的是整个原型链中是否存在构造函数的 prototype，而非直接原型的同一性；5. 实际应用中，判断原型相同可用于精确类型检查、性能优化、序列化恢复对象行为以及元编程等场景，帮助开发者更精细地控制对象行为。
在JavaScript里，要判断两个对象是否拥有相同的原型，最直接且推荐的方式是使用
Object.getPrototypeOf()
Object.getPrototypeOf(obj1) === Object.getPrototypeOf(obj2)
判断两个JavaScript对象是否共享同一个原型，核心在于获取它们内部的
[[Prototype]]
[[Prototype]]
最标准、最推荐的方法是使用
Object.getPrototypeOf()
[[Prototype]]
function haveSamePrototype(obj1, obj2) {
// 确保传入的都是对象，或者至少不是原始值
if (obj1 === null || typeof obj1 !== 'object' ||
obj2 === null || typeof obj2 !== 'object') {
// 原始值没有原型链的概念，或者说它们的“原型”是其包装对象的原型，但通常不这么比较
// 这里的处理可以根据具体需求调整，比如抛出错误或返回false
return false;
}
return Object.getPrototypeOf(obj1) === Object.getPrototypeOf(obj2);
}
// 示例：
let objA = {};
let objB = {};
console.log(haveSamePrototype(objA, objB)); // true (都继承自 Object.prototype)
function MyConstructor() {}
let instanceX = new MyConstructor();
let instanceY = new MyConstructor();
console.log(haveSamePrototype(instanceX, instanceY)); // true (都继承自 MyConstructor.prototype)
let arr1 = [];
let arr2 = [];
console.log(haveSamePrototype(arr1, arr2)); // true (都继承自 Array.prototype)
console.log(haveSamePrototype(objA, instanceX)); // false (一个继承自 Object.prototype，一个继承自 MyConstructor.prototype)
console.log(haveSamePrototype(objA, arr1)); // false (一个继承自 Object.prototype，一个继承自 Array.prototype)
// 特殊情况：null没有原型
console.log(Object.getPrototypeOf(Object.create(null))); // null
let nullProtoObj1 = Object.create(null);
let nullProtoObj2 = Object.create(null);
console.log(haveSamePrototype(nullProtoObj1, nullProtoObj2)); // true (都继承自 null，即没有原型)这个方法的好处在于它直接、语义明确，并且是ECMAScript标准的一部分，因此在各种环境中都表现一致且可靠。它获取的是对象最直接的那个原型，也就是它从哪里继承属性和方法的。
Object.getPrototypeOf()
.__proto__
谈到获取对象原型，很多人可能会想到
.__proto__
Object.getPrototypeOf()
Object
[[Prototype]]
而
.__proto__
Object.prototype
Object.prototype
.__proto__
.__proto__
.__proto__
[[Prototype]]
.__proto__
let myObj = {
__proto__: '我是一个普通属性，不是原型！'
};
console.log(myObj.__proto__); // '我是一个普通属性，不是原型！'
console.log(Object.getPrototypeOf(myObj)); // [Object: null prototype] {} (这是myObj真正的原型，一个空对象字面量的原型)这种情况下，
.__proto__
Object.getPrototypeOf()
所以，我的建议是：如果你只是想安全地读取一个对象的原型，始终使用
Object.getPrototypeOf()
Object.setPrototypeOf()
.__proto__
instanceof
instanceof
instanceof
Object
constructor.prototype
Object
Object
constructor
举个例子，你可能会觉得：
function Foo() {}
let a = new Foo();
let b = new Foo();
console.log(a instanceof Foo && b instanceof Foo); // true
console.log(Object.getPrototypeOf(a) === Object.getPrototypeOf(b)); // true看起来好像都能判断。但考虑以下情况：
function Parent() {}
function Child() {}
Child.prototype = Object.create(Parent.prototype); // Child继承Parent
let obj1 = new Child();
let obj2 = new Parent();
console.log(Object.getPrototypeOf(obj1) === Object.getPrototypeOf(obj2)); // false
// obj1 的直接原型是 Child.prototype
// obj2 的直接原型是 Parent.prototype
// 它们当然不相同
console.log(obj1 instanceof Parent); // true (因为 Parent.prototype 在 obj1 的原型链上)
console.log(obj2 instanceof Parent); // true在这个例子中，
obj1
Child
obj2
Parent
Child.prototype
Parent.prototype
Object.getPrototypeOf(obj1) === Object.getPrototypeOf(obj2)
false
然而，
obj1 instanceof Parent
true
instanceof
obj1
Parent.prototype
obj1
Child.prototype
Parent.prototype
Object.prototype
obj1
Parent
所以，
instanceof
Object.getPrototypeOf(obj1) === Object.getPrototypeOf(obj2)
Object.getPrototypeOf()
虽然听起来有点抽象，但在实际的JavaScript开发中，判断两个对象是否拥有相同的原型，其实有不少实用场景，尤其是在你需要对对象进行更细粒度的类型检查、优化或者内部机制设计时。
精确的类型检查与行为预判： 当
typeof
instanceof
Object.create()
function createMyInternalObject() {
// 内部逻辑...
return { /* ... */ }; // 假设这里返回的对象都隐式地拥有某个特定原型
}
// 假设内部实现会确保返回的对象共享一个特定原型，例如通过 Object.setPrototypeOf 或直接返回一个特定构造器的实例
// 简化：
const MyPrivateProto = {
_tag: 'MyInternalType',
doSomething() { console.log('Doing internal stuff.'); }
};
function createMyInternalObjectV2() {
return Object.create(MyPrivateProto);
}
let objA = createMyInternalObjectV2();
let objB = createMyInternalObjectV2();
let objC = {}; // 普通对象
if (Object.getPrototypeOf(objA) === MyPrivateProto) {
console.log("objA 是我们内部创建的对象，可以调用其内部方法。");
objA.doSomething();
}
console.log(Object.getPrototypeOf(objA) === Object.getPrototypeOf(objB)); // true
console.log(Object.getPrototypeOf(objA) === Object.getPrototypeOf(objC)); // false这在处理内部API、框架组件或特定数据结构时特别有用，它确保了对象不仅“看起来”像某种类型，而且确实是该类型家族的成员。
优化与性能考量： 在某些高性能要求的场景下，如果确定一组对象共享同一个原型，你可能会进行一些优化。例如，如果一个函数接收多个参数，并且你知道这些参数都是由同一个构造函数创建的，那么它们共享相同的方法集。这样，你可以避免不必要的属性查找或类型检查，直接调用原型上的方法，从而可能带来微小的性能提升。这在游戏开发、图形渲染或大数据处理等领域，对大量相似对象进行迭代操作时可能会被考虑。
序列化与反序列化： 当你需要将JavaScript对象序列化为JSON字符串，然后再反序列化回来时，默认情况下，方法和原型链上的属性是不会被序列化的。如果你的对象依赖于其原型上的方法，那么简单地
JSON.parse()
function MyClass() { this.value = 10; }
MyClass.prototype.getValue = function() { return this.value; };
let instance = new MyClass();
let jsonString = JSON.stringify(instance); // {"value":10}
let parsedObject = JSON.parse(jsonString);
console.log(parsedObject.getValue); // undefined
// 假设我们知道这是MyClass的实例
if (Object.getPrototypeOf(parsedObject) !== MyClass.prototype) {
Object.setPrototypeOf(parsedObject, MyClass.prototype); // 重新设置原型
}
console.log(parsedObject.getValue()); // 10当然，这只是一个简化示例，实际中更复杂的反序列化可能需要更精妙的策略，但原型比较是其中一个环节。
元编程与反射： 在一些高级的JavaScript应用，比如构建ORM（对象关系映射）、依赖注入框架或者自定义的类型系统时，你可能需要检查或操作对象的原型链。判断原型是否相同，是进行这些“元操作”的基础。它允许你动态地分析对象的结构和行为，并根据需要进行调整。
总的来说，判断原型相同，是深入理解和控制JavaScript对象行为的一个关键工具。它提供了比
typeof
instanceof
以上就是js如何判断两个对象原型相同的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
591
收藏
