不能完全阻止原型链扩展，但可通过object.preventextensions、object.seal和object.freeze限制对象自身及其原型的修改；2. 避免污染全局原型，应使用模块化、不直接修改内置原型，并用object.prototype.hasownproperty.call进行属性检查；3. 运行时可通过检测原型属性、防御性编程和隔离高风险代码来应对原型链被意外修改；4. 安全添加共享方法应使用class语法或构造函数的prototype属性，避免触碰内置对象原型；5. 原型链被修改后应检测、规避影响，而非尝试撤销，因直接修复风险高且不可靠。
JavaScript中，我们很难说能够“阻止”原型链的“扩展”，尤其对于那些内置对象（比如
Object.prototype
Array.prototype
要限制或规避原型链被不当修改，我们可以从几个层面入手：
1. 保护特定对象本身及其直接原型链接
这是最直接的手段，通过JS内置的
Object
Object.preventExtensions(obj)
obj
const protoObj = {
methodA: function() { console.log('A'); }
};
Object.preventExtensions(protoObj);
// 尝试添加新属性，会失败（严格模式下抛错）
// protoObj.newMethod = function() {}; // TypeError: Cannot add property newMethod, object is not extensibleObject.seal(obj)
preventExtensions
const sealedProto = {
value: 10,
action: function() { console.log(this.value); }
};
Object.seal(sealedProto);
// sealedProto.newValue = 20; // TypeError
// delete sealedProto.value; // TypeError
sealedProto.value = 100; // OKObject.freeze(obj)
const frozenProto = {
constant: 'immutable',
greet: function() { console.log(this.constant); }
};
Object.freeze(frozenProto);
// frozenProto.newProp = 'test'; // TypeError
// delete frozenProto.constant; // TypeError
// frozenProto.constant = 'mutable'; // TypeError需要注意的是，这些方法都是“浅”操作，它们只作用于目标对象本身，如果目标对象内部有其他对象（比如嵌套对象或数组），那些内部对象仍然是可变的。
2. 避免污染全局原型
很多时候，问题不是出在“阻止”某个具体原型被扩展，而是避免我们自己或者第三方库“不小心”或“恶意”地扩展了像
Object.prototype
Array.prototype
Object.prototype
Array.prototype
Object.prototype.hasOwnProperty.call()
for (let key in someObject) {
if (Object.prototype.hasOwnProperty.call(someObject, key)) {
// 这是对象自身的属性
console.log(key, someObject[key]);
}
}3. 运行时检测与防御
如果你怀疑原型链被不当修改，或者想在运行时进行防御，可以做一些检查。
Object.prototype
这是一个老生常谈但又极其重要的问题。在我看来，随意扩展内置对象的原型链，简直就是给自己挖坑，而且这个坑可能深不见底。
首先，命名冲突和覆盖。你给
Array.prototype
myCustomMethod
其次，非标准行为和可维护性。你的代码在你的环境里跑得好好的，因为你改了原型。但换个环境，或者JS引擎更新了，可能就出问题了。这让代码变得难以移植，也让后来的维护者摸不着头脑：“这个
Array
foo
再者，性能影响。虽然现代JS引擎对原型链的优化已经很好了，但在某些极端情况下，过长或被频繁修改的原型链仍然可能带来轻微的性能开销，尤其是在进行属性查找时。这有点像你找东西，如果东西被放在一个特别乱、层层叠叠的柜子里，肯定比放在整齐划一的抽屉里慢。
最后，也是最关键的，安全隐患——原型链污染攻击 (Prototype Pollution)。这是一种非常危险的漏洞。如果攻击者能够通过某种方式（比如JSON解析、数据合并操作等）向
Object.prototype
Object.prototype
Object.prototype
isAdmin: true
所以，出于稳定性、可维护性、兼容性和安全性的考虑，我们应该极力避免直接修改内置对象的原型链。
当我们谈到为自定义对象添加共享方法时，现代JavaScript提供了非常优雅且安全的方式，告别了过去直接操作
prototype
1. 使用ES6的class
这是最推荐的方式。
class
class MyCustomObject {
constructor(name, value) {
this.name = name;
this.value = value;
}
// 这就是添加到 MyCustomObject.prototype 上的方法
displayInfo() {
console.log(`Name: ${this.name}, Value: ${this.value}`);
}
// 也可以添加静态方法，不属于实例，属于类本身
static createDefault() {
return new MyCustomObject('Default', 0);
}
}
const obj1 = new MyCustomObject('Item A', 100);
obj1.displayInfo(); // Name: Item A, Value: 100
const defaultObj = MyCustomObject.createDefault();
defaultObj.displayInfo(); // Name: Default, Value: 0使用
class
prototype
2. 传统的构造函数与prototype
虽然
class
prototype
class
class
prototype
function OldSchoolObject(id, data) {
this.id = id;
this.data = data;
}
// 直接添加到构造函数的原型上
OldSchoolObject.prototype.printData = function() {
console.log(`ID: ${this.id}, Data: ${this.data}`);
};
OldSchoolObject.prototype.updateData = function(newData) {
this.data = newData;
};
const oldObj = new OldSchoolObject('ABC', { status: 'active' });
oldObj.printData(); // ID: ABC, Data: { status: 'active' }
oldObj.updateData({ status: 'inactive' });
oldObj.printData(); // ID: ABC, Data: { status: 'inactive' }这种方式也完全安全，因为它只影响你自己的
OldSchoolObject
无论是使用
class
prototype
Object.prototype
Array.prototype
虽然我们努力避免，但现实世界里，原型链，尤其是内置对象的原型链，偶尔还是会被一些不那么规范的第三方库或遗留代码“污染”。当这种情况发生时，我们能做的通常是“检测”和“规避”，而不是“撤销”或“阻止”已经发生的修改，因为后者几乎是不可能或极其危险的。
1. 运行时检测和排查
这是第一步。你需要确认到底哪个原型被修改了，以及被添加了什么。
检查Object.prototype
Array.prototype
// 看看 Object.prototype 上是不是多了什么不该有的东西 console.log(Object.getOwnPropertyNames(Object.prototype)); // 或者只看可枚举的 console.log(Object.keys(Object.prototype)); // 同样检查 Array.prototype console.log(Object.getOwnPropertyNames(Array.prototype));
通过这些输出，你可以大致判断哪些“陌生”的方法或属性被添加了。
隔离问题代码: 如果你怀疑是某个特定的第三方库导致的问题，尝试在没有该库的情况下运行你的应用，看问题是否消失。这有点像“二分法”调试，逐步排除可疑模块。
2. 防御性编程策略
既然已经发生了，我们能做的就是尽量减少其影响。
始终使用hasOwnProperty
Object.prototype.hasOwnProperty.call(obj, prop)
避免for...in
for...in
Array.prototype
for...in
for...of
forEach
map
filter
const myArray = [1, 2, 3];
// 如果 Array.prototype 被污染，for...in 会有问题
// for (let item in myArray) { console.log(item); } // 可能会输出 '0', '1', '2', 'somePollutedMethod'
// 推荐：
for (let item of myArray) { console.log(item); } // 只输出 1, 2, 3
myArray.forEach(item => console.log(item)); // 只输出 1, 2, 33. 考虑运行时修补（非常规手段）
这通常不是一个推荐的通用解决方案，因为它风险很高，而且可能导致更多问题。但在某些极端情况下，你可能需要考虑：
delete Object.prototype.someBadMethod;
总的来说，面对原型链被意外修改的情况，最佳策略是预防和检测。一旦发生，则通过防御性编程来规避其影响，并尽可能找出源头并修复（例如，更新或替换有问题的第三方库）。试图“撤销”或“阻止”已发生的修改，往往是得不偿失的。
以上就是js如何阻止原型链的扩展的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告
收藏
收藏
收藏
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
393
