闭包不直接保护原型上的共享状态，而是通过将可变状态封装在闭包内、仅暴露受控方法来间接实现保护；原型上只放方法，不挂载可变属性。
闭包本身不直接用于“保护原型对象上的共享状态”，因为原型（prototype）是所有实例共享的，而闭包保护的是**函数作用域内的私有变量**——这两者属于不同封装层级。想用闭包来间接保护原型上可能被误改的共享数据，核心思路是：**不让共享状态暴露在原型上，而是把真正可变的状态藏在闭包里，只通过受控方法访问**。
避免把可变状态直接挂到原型上
原型上的属性默认是共享且可写的。如果把计数器、缓存、配置等直接定义在 MyClass.prototype.count 或 MyClass.prototype.cache 上，任何代码都能 obj.count = 999 或 delete obj.cache，无法限制。
- ❌ 错误做法：把状态直接写在原型上
- ✅ 正确做法：原型只放方法，状态由闭包或构造函数私有变量承载
用工厂函数 + 闭包封装共享逻辑（推荐）
如果你需要多个实例共用同一份状态（比如全局计数器、统一配置、连接池），但又不想让外部随意修改，可以用一个外层闭包包裹该状态，再通过返回的构造函数或方法暴露受控接口：
const createSharedCounter = (() => {
let sharedCount = 0; // 真正的共享状态，被闭包保护
return {
increment: () => { sharedCount++; return sharedCount; },
reset: () => { sharedCount = 0; },
get: () => sharedCount
};
})();
// 所有实例调用的都是同一套受控逻辑
function Counter() {}
Counter.prototype.next = () => createSharedCounter.increment();
Counter.prototype.reset = () => createSharedCounter.reset();
Counter.prototype.value = () => createSharedCounter.get();
这样，sharedCount 永远不会出现在原型链或实例上，外部无法 Counter.sharedCount = 100，只能走 increment 和 get。
立即学习“Java免费学习笔记（深入）”；
用模块模式隔离原型方法与私有状态
把原型方法定义在闭包内，使其能访问闭包中的私有变量，同时不暴露变量本身：
const CounterModule = (function() {
const sharedState = { count: 0, max: 100 };
function Counter() {}
Counter.prototype.inc = function() {
if (sharedState.count < sharedState.max) {
sharedState.count++;
}
};
Counter.prototype.val = function() {
return sharedState.count;
};
// 可选：提供重置等管理方法
Counter.resetAll = function() {
sharedState.count = 0;
};
return Counter;
})();
const a = new CounterModule();
const b = new CounterModule();
a.inc(); b.inc();
console.log(a.val()); // 2 —— 共享状态，但不可直改
// CounterModule.sharedState → undefined
这里 sharedState 是闭包变量，Counter.prototype 上的方法可以访问它，但外部完全无法触达该对象。
注意原型继承与闭包的配合边界
闭包不能阻止对原型本身的修改（比如 Counter.prototype.inc = null），但它能确保：即使原型方法被替换，只要原始方法还在运行，它们仍操作的是受保护的闭包变量。若需更强防护，可结合 Object.freeze(Counter.prototype) 冻结原型对象（仅冻结自身属性，不影响闭包逻辑）。
本质上，闭包保护的是“值”，不是“位置”。原型是公开的访问路径，所以策略不是去锁住原型，而是让原型方法背后的数据不在原型上——藏起来，只留门。
