判断JS对象原型是否可配置，可通过Object.defineProperty方法设置configurable属性为true。若设置成功，则说明原型可配置；否则不可配置。

小伙伴们有没有觉得学习文章很有意思？有意思就对了！今天就给大家带来《如何判断JS对象原型是否可配置》，以下内容将会涉及到，若是在学习中对其中部分知识点有疑问，或许看了本文就能帮到你！

判断一个对象的原型链是否可被修改，核心在于检查其是否被密封或冻结，因为Object.isSealed()或Object.isFrozen()返回true时，原型链不可变；对于仅不可扩展的对象，原型链通常仍可修改，最可靠的判断方式是尝试使用Object.setPrototypeOf()并捕获TypeError，若抛出错误则不可修改，否则可修改。

JavaScript中，判断一个对象的原型链是否可被修改（即其内部的[[Prototype]]槽位能否被重设），核心在于理解对象自身的状态。直接去问“原型是否可配置”这个说法，其实有点模糊，因为“可配置”通常是针对属性描述符而言的。但如果你的意思是“能否通过Object.setPrototypeOf()来改变它的原型”，那答案主要取决于对象自身的“可扩展性”、“密封性”或“冻结性”。

解决方案

要判断一个对象的原型是否可被修改，我们通常会检查该对象是否处于不可扩展、密封或冻结状态。这些状态会限制对对象结构的修改，包括其原型链。

• Object.isExtensible(obj): 如果对象不可扩展，则不能向其添加新属性。虽然这不直接禁止修改原型，但在某些JavaScript引擎的实现中，如果一个对象不可扩展，其原型链也可能被视为不可修改。
• Object.isSealed(obj): 如果对象被密封，则不能添加或删除属性，也不能重新配置现有属性。这意味着你不能删除或重新配置像__proto__这样的访问器属性（如果它存在并被暴露），也无法改变其原型链。
• Object.isFrozen(obj): 如果对象被冻结，它不仅密封，而且其现有属性的值也不能被修改。这是最严格的状态，显然会阻止原型链的任何变动。

因此，最直接且可靠的判断方式是：如果一个对象是冻结的或密封的，那么它的原型链就无法通过Object.setPrototypeOf()来改变。对于仅仅是不可扩展的对象，理论上原型链可能可以改变，但实践中很少见到这种场景，而且通常不推荐这样做。

function canChangePrototype(obj) {
  // 如果对象被冻结或密封，其原型链是不可改变的
  if (Object.isFrozen(obj) || Object.isSealed(obj)) {
    return false;
  }
  // 理论上，如果对象只是不可扩展，原型链仍可能可变
  // 但在实际开发中，如果一个对象连新属性都不能加，改变其原型链也通常不是期望的行为
  // 所以这里可以根据具体需求决定是否将不可扩展也视为不可变
  // 例如：
  // if (!Object.isExtensible(obj)) {
  //   return false;
  // }

  // 尝试修改原型，并捕获错误
  try {
    const originalProto = Object.getPrototypeOf(obj);
    // 尝试将其原型设置为自身，这通常会失败并抛出TypeError，但可以测试其可变性
    // 或者设置为一个空对象，然后立即改回去
    Object.setPrototypeOf(obj, {}); // 尝试修改
    Object.setPrototypeOf(obj, originalProto); // 改回去
    return true; // 如果没有抛出错误，说明可修改
  } catch (e) {
    // 捕获到TypeError，说明原型不可修改
    if (e instanceof TypeError) {
      return false;
    }
    // 其他错误，可能是其他问题
    throw e;
  }
}

// 示例
const obj1 = {};
console.log('obj1 原型可变性:', canChangePrototype(obj1)); // true

const obj2 = Object.freeze({});
console.log('obj2 (冻结) 原型可变性:', canChangePrototype(obj2)); // false

const obj3 = Object.seal({});
console.log('obj3 (密封) 原型可变性:', canChangePrototype(obj3)); // false

const obj4 = Object.preventExtensions({});
console.log('obj4 (不可扩展) 原型可变性:', canChangePrototype(obj4));
// 这里的结果可能因JS引擎行为而异，但通常也意味着无法改变原型
// 在V8 (Chrome/Node.js) 中，Object.preventExtensions() 后 Object.setPrototypeOf 仍可能成功，
// 除非新原型是自身，或者对象已经是冻结/密封的。
// 但为了严谨，上述canChangePrototype函数通过try-catch来判断是最可靠的。
// 实际上，对于 preventExtensions 的对象，setPrototypeOf 往往也是成功的，因为原型链的修改不被视为“添加新属性”。
// 因此，我的 canChangePrototype 函数中，对 preventExtensions 的处理是：
// 如果 Object.isFrozen 或 Object.isSealed 才会返回 false。
// 这也符合了规范：setPrototypeOf 的失败条件是：新原型不是对象/null，或者对象被冻结/密封。
// 所以，对于仅仅 preventExtensions 的对象，其原型是可修改的。

理解原型链与可配置性：概念辨析

当我们谈论JavaScript中“可配置性”时，它通常是Object.defineProperty()或Object.getOwnPropertyDescriptor()返回的属性描述符中的一个布尔值，表示该属性是否可以被删除，或者其writable、enumerable、configurable属性是否可以被修改。

但对于“对象的原型是否可配置”这个表述，它其实指向了两个层面：

1. 属性的configurable特性：这指的是一个对象上某个特定属性（比如myObj.propA）的configurable描述符。如果propA的configurable为true，那么你可以删除propA，或者改变它的writable、enumerable、configurable状态。这与整个对象的原型链是否可变是两回事。
2. 对象[[Prototype]]内部槽位的可变性：这是我们前面主要讨论的。每个JavaScript对象都有一个指向其原型对象的内部[[Prototype]]槽位。这个槽位决定了属性查找的路径。ES6引入的Object.setPrototypeOf()方法就是用来修改这个槽位的。这个修改操作是否成功，并不直接由一个名为prototypeConfigurable的属性描述符控制，而是由对象自身的整体状态（是否冻结、密封）来决定。

简单来说，如果你想知道能否改变一个对象“继承自谁”，你需要关注Object.isFrozen()和Object.isSealed()。如果你想知道一个对象上的某个特定属性（包括它可能存在的__proto__属性）能否被删除或重新定义，那才是真正去看那个属性的configurable描述符。

值得注意的是，__proto__这个非标准但广泛使用的属性，它在大多数环境中是Object.prototype上的一个访问器属性（getter/setter），它的configurable描述符通常是true。这意味着你可以删除Object.prototype.__proto__这个属性。但对于一个具体的实例对象myObj，myObj.__proto__实际上是访问其内部[[Prototype]]槽位的快捷方式，而不是myObj自身的一个可枚举属性。因此，去检查Object.getOwnPropertyDescriptor(myObj, '__proto__')通常是无意义的，除非你真的在myObj上显式定义了一个名为__proto__的属性。

实际判断方法与代码示例：深挖ObjectAPI

要深入判断，我们需要结合多种Object API。

1. 检查对象的密封/冻结状态：

这是最直接也最常用的方法，因为它们明确地限制了原型链的修改。

const myObject = {};
const sealedObject = Object.seal({});
const frozenObject = Object.freeze({});
const nonExtensibleObject = Object.preventExtensions({});

console.log('myObject 是否可修改原型:', !(Object.isSealed(myObject) || Object.isFrozen(myObject))); // true
console.log('sealedObject 是否可修改原型:', !(Object.isSealed(sealedObject) || Object.isFrozen(sealedObject))); // false
console.log('frozenObject 是否可修改原型:', !(Object.isSealed(frozenObject) || Object.isFrozen(frozenObject))); // false
console.log('nonExtensibleObject 是否可修改原型:', !(Object.isSealed(nonExtensibleObject) || Object.isFrozen(nonExtensibleObject))); // true (在V8等引擎中，preventExtensions不阻止setPrototypeOf)

// 尝试修改nonExtensibleObject的原型
try {
  Object.setPrototypeOf(nonExtensibleObject, { newProto: true });
  console.log('nonExtensibleObject 原型修改成功！新原型:', Object.getPrototypeOf(nonExtensibleObject));
} catch (e) {
  console.error('nonExtensibleObject 原型修改失败:', e.message);
}
// 结果会是成功，这再次印证了 Object.preventExtensions() 本身不阻止原型修改。

2. 尝试Object.setPrototypeOf()并捕获错误：

这是最可靠的“试错”方法，直接模拟修改行为，如果抛出TypeError，则说明不可修改。

function checkPrototypeModifiable(obj) {
  const originalProto = Object.getPrototypeOf(obj);
  try {
    // 尝试修改为一个不同的原型，然后立即改回，避免副作用
    Object.setPrototypeOf(obj, Object.prototype); // 或者任何非自身的新原型
    Object.setPrototypeOf(obj, originalProto); // 恢复
    return true;
  } catch (e) {
    if (e instanceof TypeError) {
      return false; // 捕获到TypeError，表示不可修改
    }
    throw e; // 其他错误继续抛出
  }
}

console.log('myObject 可修改原型:', checkPrototypeModifiable({})); // true
console.log('Object.freeze({}) 可修改原型:', checkPrototypeModifiable(Object.freeze({}))); // false
console.log('Object.seal({}) 可修改原型:', checkPrototypeModifiable(Object.seal({}))); // false
console.log('Object.preventExtensions({}) 可修改原型:', checkPrototypeModifiable(Object.preventExtensions({}))); // true

3. 检查__proto__访问器属性的configurable性（仅供参考，不推荐依赖）：

__proto__作为Object.prototype上的一个访问器属性，其自身是可配置的。

const protoDescriptor = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__');
console.log('Object.prototype.__proto__ 的描述符:', protoDescriptor);
// 结果通常是：
// {
//   get: [Function: get __proto__],
//   set: [Function: set __proto__],
//   enumerable: false,
//   configurable: true // 注意这里是true
// }

这表明Object.prototype上的__proto__属性本身是可以被删除或重新定义的。但这并不意味着任何对象的[[Prototype]]槽位都可以被修改。对于实例对象，它们通常没有自己的__proto__属性，而是通过原型链继承了Object.prototype上的__proto__访问器。因此，直接修改obj.__proto__或使用Object.setPrototypeOf()的行为，最终还是受限于对象自身的内部状态。

总结来说，判断一个对象的原型是否可被修改，最可靠且符合现代JavaScript规范的方式是检查Object.isFrozen()和Object.isSealed()，或者直接尝试Object.setPrototypeOf()并捕获TypeError。

为什么原型链可配置性很重要：设计考量与潜在风险

理解和控制原型链的可配置性，在JavaScript的设计和实际应用中都具有深远的影响。

设计考量：

• 封装与不变性：在构建复杂系统时，我们常常需要确保某些对象的状态是不可变的，以避免意外的副作用或数据损坏。冻结（Object.freeze）和密封（Object.seal）就是实现这种不变性的强大工具。当一个对象被冻结或密封后，其原型链的不可变性是这种不变性保证的一部分。如果原型可以随意改变，那么即使对象自身属性不可变，其行为（通过原型继承）仍然可能被篡改。
• 性能优化：JavaScript引擎对对象和原型链进行了大量的优化。当原型链保持稳定时，引擎可以进行更积极的内联缓存和优化。频繁地改变一个对象的原型链（通过Object.setPrototypeOf）会强制引擎去优化或重新编译相关的代码，这可能会导致性能下降，尤其是在热点代码路径中。因此，规范建议在创建对象时就确定其原型，而不是在运行时频繁修改。
• 模块化与安全性：在一些高级场景，如实现沙箱环境或处理来自不可信源的数据时，限制原型链的修改能力是至关重要的。它可以防止恶意代码通过修改核心对象的原型来劫持内置方法（例如，修改Object.prototype.toString或Array.prototype.push），从而导致“原型污染”攻击。

潜在风险：

• 原型污染（Prototype Pollution）：这是最常见的安全风险。如果攻击者能够控制应用程序中的某个对象并向其添加或修改属性，并且该应用程序没有正确地验证输入，那么攻击者可能能够修改Object.prototype或Array.prototype等全局对象的原型。一旦这些原型被修改，所有从它们继承的对象都会受到影响，可能导致远程代码执行、拒绝服务或其他严重漏洞。限制原型链的可配置性（通过冻结关键对象）是防范此类攻击的一种策略。
• 意外行为：在大型代码库或团队协作中，如果某个模块意外地修改了共享对象的原型链，可能会导致其他依赖该对象行为的模块出现难以追踪的bug。这种行为通常是隐蔽的，因为它改变了对象的继承链，而不是直接改变其自身属性。
• 调试复杂性：动态改变原型链会使代码的执行路径变得更加复杂和难以预测，从而增加了调试的难度。当一个方法调用失败或行为异常时，你不仅要检查对象自身，还要检查其整个原型链上的所有可能被修改过的原型。

因此，除非有非常明确和高级的元编程需求（例如，某些polyfill或框架层面的优化），否则通常不建议在运行时频繁或随意地修改对象的原型链。保持原型链的稳定性和可预测性，对于构建健壮、安全和高性能的JavaScript应用至关重要。

今天关于《判断JS对象原型是否可配置，可通过Object.defineProperty方法设置configurable属性为true。若设置成功，则说明原型可配置；否则不可配置。》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！