怎么在JavaScript构造函数中实现私有变量

在传统的 JavaScript 构造函数中，直接给 this 赋值创建的属性都是外部可直接读写的公共属性。实现私有变量最核心且直接的方案是：将变量声明为构造函数内的局部变量，并通过挂载在 this 上的闭包函数（通常称为特权方法）来间接访问和修改该变量。外部代码无法跨越函数词法作用域直接获取内部变量，从而实现真正意义上的数据隐藏与安全封装。

一、暴露的问题：为什么构造函数中的 this 不能防守外部篡改

很多初学者在编写面向对象代码时，习惯将所有状态都挂载在实例上。例如创建一个银行账户实例：

function BankAccount(initialBalance) {
  this.balance = initialBalance;
}

const account = new BankAccount(100);
// 外部调用者可以直接绕过校验规则随意改写
account.balance = -500;
console.log(account.balance); // -500

这里的 balance 没有任何防线。只要获得对象引用，任何业务模块都能绕过校验逻辑修改数据。要在 JavaScript 传统的构造函数中封堵这一漏洞，关键在于区分“挂在对象上的属性”与“存在于作用域中的变量”。

二、核心实现：通过局部变量与特权方法建立封闭防线

JavaScript 的函数每次执行都会创建独立的作用域执行上下文。如果我们在构造函数内部用 let、const 或 var 声明变量，外部作用域绝无可能直接跨越边界读取该变量。与此同时，挂载在 this 上的方法因形成闭包，依然持有对这块词法环境的持久引用。

下面是一个完整的、包含存取控制的实现示例：

function UserAccount(username, initialDeposit) {
  // 1. 局部变量：仅在构造函数执行期间创建在词法环境中
  let balance = initialDeposit > 0 ? initialDeposit : 0;
  const createdAt = new Date();

  // 2. 公共属性：可自由读取
  this.username = username;

  // 3. 特权方法：借助闭包读取私有变量
  this.getBalance = function() {
    return balance;
  };

  // 4. 特权方法：借助闭包修改私有变量（带有防篡改校验）
  this.deposit = function(amount) {
    if (typeof amount !== 'number' || amount <= 0) {
      console.warn('存入金额必须大于零');
      return false;
    }
    balance += amount;
    return true;
  };

  this.withdraw = function(amount) {
    if (amount > 0 && amount <= balance) {
      balance -= amount;
      return true;
    }
    console.warn('取款金额不合法或余额不足');
    return false;
  };
}

// 验证效果
const user = new UserAccount('张三', 500);

console.log(user.username);     // "张三"（公共属性）
console.log(user.balance);      // undefined（无法直接从外部读取）
console.log(user.getBalance());  // 500（必须调用特权方法）

user.deposit(200);
console.log(user.getBalance());  // 700

// 尝试非法篡改
user.balance = 999999;          // 只是在实例上添加了无关的新属性
console.log(user.getBalance());  // 依然是 700，私有状态完好无损

这一模式下，balance 并非挂在 user 对象上的键值对，因此 Object.keys(user)、for...in 循环以及 JSON.stringify(user) 都无法触碰到底层的真实状态。这就是 JavaScript 经典而有效的私有化方式。

三、权衡与代价：闭包方案的内存复用瓶颈

闭包特权方法虽然彻底隔绝了外部访问，但它带来了一个在高性能或海量对象场景下不容忽视的问题：方法无法在原型链上共享。

普通原型方法（如 UserAccount.prototype.sayHi）在内存中只存在一份拷贝，无论 new 产生多少个实例，大家共用同一个函数体。然而，为了持有闭包变量，特权方法必须在每次调用构造函数时重新创建并绑定到当前 this。如果创建 10,000 个实例，内存中就会生成 10,000 个独立的 getBalance、deposit 和 withdraw 函数对象。

四、进阶方案：利用 WeakMap 实现原型方法共享的硬私有

如果既希望保护私有变量，又希望把方法挂在 UserAccount.prototype 上以节省内存，可以借助 ES6 引入的 WeakMap。

WeakMap 的键必须是对象引用，并且对键是弱引用（不会阻碍垃圾回收）。我们将实例作为键，将私有数据对象作为值。只要把 WeakMap 存放在外部无法访问的模块作用域中，就能完美兼顾“私有保护”与“原型共享”。

结合模块封装的代码如下：

// 配合立即执行函数（IIFE）或 ES 模块，确保 privateStore 不被导出
const BankAccount = (function() {
  const privateStore = new WeakMap();

  function BankAccount(initialBalance) {
    // 将当前实例作为 key，私有属性集合作为 value 存入
    privateStore.set(this, {
      balance: initialBalance > 0 ? initialBalance : 0
    });
  }

  // 方法定义在 prototype 上，所有实例共享同一函数引用
  BankAccount.prototype.getBalance = function() {
    const state = privateStore.get(this);
    if (!state) {
      throw new Error('无效的实例访问');
    }
    return state.balance;
  };

  BankAccount.prototype.deposit = function(amount) {
    if (amount <= 0) return false;
    const state = privateStore.get(this);
    state.balance += amount;
    return true;
  };

  return BankAccount;
})();

const acc1 = new BankAccount(100);
const acc2 = new BankAccount(200);

console.log(acc1.getBalance()); // 100
console.log(acc2.getBalance()); // 200
console.log(acc1.getBalance === acc2.getBalance); // true（原型方法共享，节省内存）

五、其他替代与常见盲区

1. 下划线前缀命名约定（如 _balance）

在早期的很多 JavaScript 库中，开发者习惯用 this._balance = initialBalance 来表示私有。需要明确的是，这仅仅是团队协作中的风格约定，在语言层面上没有任何私有性保护，外部属性依然可以被任意遍历、读取和修改。

2. Symbol 属性命名

ES6 引入了 Symbol，可以将唯一标识符作为属性键：

const _balance = Symbol('balance');
function Account(val) {
  this[_balance] = val;
}

这种做法可以防止普通 Object.keys() 遍历和命名冲突，但不是真正的私有：外部调用者通过 Object.getOwnPropertySymbols(instance) 依然能够拿到该 Symbol 并读取属性值。

3. 现代 Class 中的原生私有字段（#field）

在较新的 ECMAScript 标准（ES2022）中，JavaScript 类已经支持使用 # 开头的原生私有字段，例如 class Account { #balance = 0; }。这是当前官方推荐的私有变量写法。不过在维护旧项目、纯函数式组件封装或不使用 Babel 转译的特定环境里，掌握构造函数中的闭包与 WeakMap 依然是扎实理解作用域的必修内功。

六、实践总结与方案选型

在实际编码中，选择哪种方式取决于项目所处的运行时环境以及对象创建的规模：

总结来说，要在传统的 JavaScript 构造函数中实现私有变量，最基础且直接的手法就是不使用 this 挂载属性，而是声明函数局部变量，并配合特权方法进行闭包捕获。当面对高频实例创建的性能诉求时，引入 WeakMap 是最经典的进阶解法；而随着 ECMAScript 语法演进，现代项目则可逐步过渡到原生类私有字段。