阻止对象修改的三种方法：Object.preventExtensions()、seal()、freeze()

来到golang学习网的大家，相信都是编程学习爱好者，希望在这里学习文章相关编程知识。下面本篇文章就来带大家聊聊《阻止对象修改原型的几种方法：Object.preventExtensions() 该方法让对象不能再添加新属性，但可以修改已有属性和删除属性。const obj = { a: 1 }; Object.preventExtensions(obj); obj.b = 2; // 不会生效 console.log(obj); // { a: 1 }Object.seal() 封闭对象，不允许添加或删除属性，但可以修改已有属性。const obj = { a: 1 }; Object.seal(obj); obj.b = 2; // 不会生效 delete obj.a; // 不会生效 obj.a = 2; // 可以修改 console.log(obj); // { a: 2 }Object.freeze() 冻结对象，不能添加、删除或修改属性（深冻结需要递归处理）。const obj = { a: 1 }; Object.freeze(obj); obj.b = 2; // 不会生效 delete obj.a; // 不会生效 obj.a = 2; // 不会生效 console.log(obj); // { a: 1 }设置 __proto__ 为不可写 通过》，介绍一下，希望对大家的知识积累有所帮助，助力实战开发！

要让一个JavaScript对象的原型链连接无法被修改，最直接有效的方法是使用Object.freeze()使其不可扩展。1. 通过Object.setPrototypeOf()设置对象的初始原型；2. 使用Object.freeze()冻结对象，使其不可扩展、不可配置且不可写；3. 此后任何尝试通过Object.setPrototypeOf()修改原型的操作都会抛出TypeError，从而确保原型链稳定。该方法之所以有效，是因为Object.setPrototypeOf()要求目标对象必须可扩展，而freeze()移除了这一特性。此外，为实现更全面的继承稳定性，还可结合Object.create(null)创建无原型对象，或冻结原型对象本身以防止其属性被修改。这种机制在防范原型链污染攻击、保护库框架核心对象、提升引擎优化效率及构建不可变系统时尤为重要，能有效保障对象结构的确定性和运行时的安全性。

要让一个JavaScript对象的原型链连接无法被修改，最直接有效的方法是让该对象变为“不可扩展”。一旦一个对象被设置为不可扩展，它的内部[[Prototype]]槽位（也就是它指向哪个原型对象）就不能再通过Object.setPrototypeOf()等方式改变了。这相当于锁定了它继承的源头。

解决方案

要让一个JavaScript对象的原型链连接无法被修改，核心在于使其“不可扩展”。Object.freeze()是其中最严格的方式，它不仅使对象不可扩展，还阻止了属性的添加、删除和修改，从而全面锁定了对象的结构及其原型链的指向。

const myLockedObject = {};
const initialPrototype = {
  get info() { return "This is the original prototype."; },
  doSomething() { console.log("Doing something from prototype."); }
};

// 1. 设置初始原型
Object.setPrototypeOf(myLockedObject, initialPrototype);
// 此时 myLockedObject 继承了 initialPrototype 的方法和属性

// 2. 冻结对象，使其原型链无法被修改
Object.freeze(myLockedObject);

// 3. 尝试修改原型，这会失败并抛出错误
try {
  Object.setPrototypeOf(myLockedObject, { newInfo: "New prototype." });
} catch (e) {
  // 在严格模式下，尝试修改一个不可扩展对象的原型会抛出 TypeError。
  // console.error("无法修改冻结对象的原型:", e.message);
}

// 此时 myLockedObject 的原型仍然是 initialPrototype，无法被更改
// Object.getPrototypeOf(myLockedObject) === initialPrototype; // 结果为 true

为什么常规的对象原型修改方法会失效？

当我们谈论修改JavaScript对象的原型时，通常指的是改变其内部的[[Prototype]]槽位，让它指向另一个对象。历史上，我们可能用过非标准的__proto__属性来做这件事，但这东西现在基本不推荐直接使用了，因为它效率不高，而且行为有些古怪。现代且标准的方法是Object.setPrototypeOf()。

Object.setPrototypeOf()这个方法，它在设计上就有一个前提：目标对象必须是“可扩展”的（extensible）。所谓“可扩展”，就是指可以向对象添加新的属性。而Object.preventExtensions()、Object.seal()和Object.freeze()这三个方法，它们的作用之一就是让对象变得不可扩展。

Object.preventExtensions(obj)：让obj变得不可扩展，不能添加新属性。 Object.seal(obj)：在preventExtensions的基础上，还把所有现有属性标记为不可配置（non-configurable），意味着你不能删除它们，也不能改变它们的enumerable或writable特性。 Object.freeze(obj)：这是最严格的，它在seal的基础上，还把所有现有属性标记为不可写（non-writable），基本上就是让对象变成完全的常量。

所以，一旦你对一个对象调用了Object.preventExtensions()、Object.seal()或Object.freeze()，它就失去了“可扩展”的特性。这时候，如果你再尝试用Object.setPrototypeOf()去改变它的原型，JavaScript引擎就会检测到这个对象是不可扩展的，然后直接抛出一个TypeError。我个人觉得，这设计得挺巧妙的，它提供了一种从根本上锁定对象结构和继承链的机制，避免了运行时意外的结构变动。这不仅仅是防止了原型链被篡改，更是对对象整体稳定性的一种保障。

除了锁定原型链，还有哪些方法可以确保对象“继承”的稳定性？

锁定一个对象的原型链连接，是确保其继承行为稳定的一个重要方面。但“继承的稳定性”这个概念其实可以更广义地理解，它还包括了对原型对象本身的保护，以及在创建对象时就确定其继承关系。

首先，最直接的，如果你压根不希望一个对象有任何继承自Object.prototype的东西，比如你只是想把它当成一个纯粹的字典来用，那么Object.create(null)就是你的好朋友。它会创建一个没有原型的对象，意味着它不会从Object.prototype继承任何方法，比如toString、hasOwnProperty等。这在某些场景下非常有用，比如避免原型链污染攻击，或者仅仅是为了一个更“干净”的对象。

const pureDictionary = Object.create(null);
// console.log(pureDictionary.toString()); // 会报错，因为没有toString方法

其次，如果你希望对象从一开始就拥有一个特定的、不可变的原型，你可以在创建时就指定它，然后把这个原型对象本身也冻结起来。

const immutableProto = {
  fixedMethod() { console.log("This method cannot be changed."); }
};
Object.freeze(immutableProto); // 冻结原型对象本身

const myObjectWithFixedProto = Object.create(immutableProto);
// myObjectWithFixedProto 的原型是 immutableProto，且 immutableProto 的属性也无法修改
// try { immutableProto.fixedMethod = () => {}; } catch (e) { console.error(e.message); } // 报错

这种做法是双重保险：不仅对象本身的原型链连接是固定的（如果myObjectWithFixedProto也被冻结），连它所指向的原型对象内部的属性和方法也是不可变的。在我看来，这才是真正意义上的“继承稳定性”——不仅指向不变，所指的内容也不变。这在构建一些核心库或框架时，对保证内部机制的健壮性非常有帮助。它体现了一种“防御性编程”的思想，尽可能地减少运行时可能出现的副作用。

什么时候我们真正需要固定一个对象的原型？应用场景分析。

固定一个对象的原型，听起来可能有点“过度保护”，但在某些特定场景下，它却是至关重要的，甚至关乎系统的安全性和稳定性。

一个非常典型的场景就是安全性，尤其是防范原型链污染攻击。在一些Node.js应用或前端框架中，如果代码不严谨，攻击者可能会通过构造特定的JSON数据或URL参数，利用某些库的漏洞，向Object.prototype注入恶意属性。一旦Object.prototype被污染，所有从它继承的对象（几乎所有普通JavaScript对象）都会受到影响，这可能导致远程代码执行、信息泄露等严重的安全问题。虽然直接锁定Object.prototype不现实，但对于一些关键的、由用户输入或外部数据构建的对象，如果它们的原型被意外修改，也可能带来不可预测的行为。在这种情况下，确保某些核心对象或配置对象的原型不被篡改，是一种有效的防御手段。

另一个重要的应用场景是库和框架的内部机制保障。如果你在开发一个JavaScript库或框架，其中有一些内部使用的对象，它们的设计和行为依赖于特定的原型链。为了防止库的使用者（无论是无意还是有意）篡改这些内部对象的原型，从而破坏库的预期行为，你可能会选择锁定这些对象的原型。这就像是给你的核心组件穿上了一层“铠甲”，确保它们在复杂的外部环境中依然能稳定运行。我见过一些大型应用，在核心模块里会特意做这种处理，以确保其内部状态和逻辑的纯粹性。

此外，在性能优化方面，虽然不是直接原因，但稳定的对象结构和原型链对JavaScript引擎的优化是有利的。V8等现代JavaScript引擎会进行大量的即时编译（JIT）优化，其中就包括对对象形状（shape）和隐藏类（hidden class）的推断。如果一个对象的原型链在运行时频繁变动，可能会导致引擎无法进行有效的优化，从而影响性能。锁定原型链，有助于引擎更好地预测对象的行为，从而应用更激进的优化策略。

最后，对于一些不可变数据结构的实现，虽然通常是通过创建新对象而非修改现有对象来达到不可变性，但“锁定原型”的思想也与此相契合。它强调的是一种确定性和可预测性：一旦对象被创建并其原型被确定，它就应该保持这种状态，不被外部因素轻易改变。这在构建复杂的状态管理系统时，可以极大地简化调试和推理的难度。

好了，本文到此结束，带大家了解了《阻止对象修改的三种方法：Object.preventExtensions()、seal()、freeze()》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多文章知识！