怎么利用JavaScript函数作用域和闭包封装私有变量

一、理解函数作用域的物理隔离机制

在 JavaScript 中，对象的普通属性是完全公开且直接暴露在外部的。如果直接在一个字面量对象中挂载状态，任何引用该对象的代码都可以随意读写该属性，甚至将其赋值为非法数据：

// 普通对象属性完全透明，无任何边界隔离
const bankAccount = {
  balance: 1000
};

// 外部可以任意篡改，无需经过任何业务校验
bankAccount.balance = -999999;
console.log(bankAccount.balance); // 输出 -999999（数据一致性被破坏）

之所以会出现这种无法防备的篡改，是因为对象的属性访问遵循的是属性查找规则，没有任何访问权限控制。要让一个变量无法被外部直接访问，就必须借助于 JavaScript 语言层面的词法作用域（Lexical Scope）。

词法作用域规定：变量的可访问范围在代码书写阶段就已被确定。函数内部通过 let、const 或 var 声明的变量，其作用域被严格限制在该函数内部。外部作用域永远无法主动“探入”函数内部读取局部变量；若强行访问，解释器在作用域链中查找无果后，会直接抛出 ReferenceError。

函数作用域为我们提供了一道天然的“单向隔离屏障”：从函数内部可以顺着作用域链向外查找全局变量，但外部环境绝对无法穿越函数边界访问内部的局部变量。这正是封装私有变量不可或缺的第一道防线。

二、闭包如何让私有变量在函数执行后持续生效

如果仅有函数作用域，每次函数调用结束后，该函数的执行上下文（Execution Context）就会从调用栈（Call Stack）弹出销毁，内部声明的局部变量也会随之被垃圾回收器释放，无法作为持久保存的状态使用。

要让局部变量在外部函数执行结束后依然存活并持续发挥作用，就必须依赖闭包（Closure）机制。闭包是指一个函数有权访问其外部词法作用域中的变量，即使外部函数已经执行完毕并退出了调用栈。

闭包封装私有变量的完整生命周期可分为四个推导步骤：

1. 步骤一：外部函数执行并开辟局部词法环境。当调用外部函数时，JavaScript 引擎在堆内存中为该函数分配一个独立的词法环境记录（Environment Record），并将需要私有化的变量（例如 count）分配在此环境中。
2. 步骤二：定义持有环境引用的内部特权方法。在外部函数体内创建内部函数。根据 ECMAScript 规范，每个内部函数在实例化时都会通过内部槽位 [[Scopes]] 引用当前所在的外部词法环境。
3. 步骤三：外部函数返回特权方法并退出调用栈。外部函数执行完毕，其栈帧从调用栈弹出。常规情况下其内部变量应被清理，但由于返回的内部函数对象被外部变量接收，引擎垃圾回收器（GC）通过可达性分析发现该词法环境仍被引用，因此保留堆内存中的变量环境。
4. 步骤四：通过暴露的特权接口操作驻留变量。外部代码调用返回的方法时，该方法沿着之前捕获的 [[Scopes]] 作用域链访问并修改保留在堆中的私有变量。

下面是一个最简洁的基础计数器代码，演示闭包封装的核心运行过程：

// 基础计数器模型：演示函数作用域与闭包特权方法
function createCounter(initialValue = 0) {
  // 1. 私有变量：位于 createCounter 的局部词法作用域内
  let privateCount = initialValue;

  // 2. 返回包含特权方法的对象，形成闭包
  return {
    increment() {
      privateCount += 1;
      return privateCount;
    },
    decrement() {
      privateCount -= 1;
      return privateCount;
    },
    getValue() {
      return privateCount;
    }
  };
}

// 3. 执行外部函数，接收特权方法集合
const counterA = createCounter(10);

console.log(counterA.getValue());   // 示例输出: 10
counterA.increment();
counterA.increment();
console.log(counterA.getValue());   // 示例输出: 12

// 4. 验证私有性：外部无法直接读取或修改 privateCount
console.log(counterA.privateCount); // 示例输出: undefined

在上述代码中，privateCount 对外部代码是不可见的，外部访问 counterA.privateCount 只能得到 undefined，因为该属性根本不存在于返回的对象上；任何对数值的变更都必须经过 increment() 与 decrement() 受控执行。

三、封装私有变量的三种典型实战模式

在实际业务开发中，根据状态的作用域范围与复用需求，通常采用以下三种封装模式。

模式一：工厂函数模式（推荐度最高，多实例隔离）

工厂函数（Factory Function）是一个普通函数，它负责创建并返回一个装配了闭包特权方法的纯对象。每次调用工厂函数，JavaScript 引擎都会开辟一块全新的独立词法环境，因此不同实例之间的私有变量互不干扰。

/**
 * 银行账户工厂函数
 * @param {string} ownerName 账户所有人
 * @param {number} initialDeposit 初始存入金额
 */
function createBankAccount(ownerName, initialDeposit = 0) {
  // 私有变量：存储在当前闭包环境中
  let _balance = initialDeposit;
  const _transactions = [
    { type: "INIT", amount: initialDeposit, timestamp: new Date().toISOString() }
  ];

  // 返回公开的接口对象（特权方法）
  return {
    // 获取所有人名称（只读）
    getOwner() {
      return ownerName;
    },

    // 存款：包含入参合法性检查
    deposit(amount) {
      if (typeof amount !== "number" || amount <= 0) {
        throw new Error("存款金额必须为正数");
      }
      _balance += amount;
      _transactions.push({
        type: "DEPOSIT",
        amount,
        timestamp: new Date().toISOString()
      });
      return _balance;
    },

    // 取款：包含防透支校验
    withdraw(amount) {
      if (typeof amount !== "number" || amount <= 0) {
        throw new Error("取款金额必须为正数");
      }
      if (amount > _balance) {
        throw new Error("账户余额不足");
      }
      _balance -= amount;
      _transactions.push({
        type: "WITHDRAW",
        amount,
        timestamp: new Date().toISOString()
      });
      return _balance;
    },

    // 查询余额
    getBalance() {
      return _balance;
    },

    // 获取流水记录（防逃逸处理：返回数组副本）
    getStatement() {
      return [..._transactions];
    }
  };
}

// 验证多实例的独立性
const accountAlice = createBankAccount("Alice", 500);
const accountBob = createBankAccount("Bob", 100);

accountAlice.deposit(200);
accountAlice.withdraw(100);

console.log(`Alice 余额: ${accountAlice.getBalance()}`); // 示例输出: 600
console.log(`Bob 余额: ${accountBob.getBalance()}`);     // 示例输出: 100 (不受 Alice 操作影响)

模式二：立即执行函数（IIFE）模块模式（单例模式）

当应用程序需要一个全局唯一的管理中心（例如系统全局配置、日志服务或会话缓存）时，不需要多次实例化，此时应使用立即执行函数表达式（Immediately Invoked Function Expression, IIFE）。

函数在脚本加载后立即执行一次，其内部私有变量在整个应用生命周期中只保留一份闭包：

// 全局配置管理模块（单例模式）
const SystemConfigManager = (() => {
  // 私有变量：仅在此 IIFE 内部可见
  const _configStore = new Map([
    ["env", "production"],
    ["timeout", 5000],
    ["retryLimit", 3]
  ]);
  let _isLocked = false;

  return {
    // 读取配置项
    getConfig(key) {
      return _configStore.get(key);
    },

    // 写入配置项（受锁保护）
    setConfig(key, value) {
      if (_isLocked) {
        console.warn(`[Config] 配置已被锁定，无法修改: ${key}`);
        return false;
      }
      _configStore.set(key, value);
      return true;
    },

    // 锁定配置
    lock() {
      _isLocked = true;
      console.log("[Config] 系统配置已上锁");
    }
  };
})();

console.log(SystemConfigManager.getConfig("env")); // 示例输出: production
SystemConfigManager.setConfig("timeout", 8000);
console.log(SystemConfigManager.getConfig("timeout")); // 示例输出: 8000

SystemConfigManager.lock();
SystemConfigManager.setConfig("timeout", 12000); // 触发锁定警告，拒绝写入

模式三：构造函数配合内部特权方法

在传统使用 new 调用的面向对象编程中，私有变量声明在构造函数体内部，而特权方法通过 this.methodName = function() { ... } 直接绑定在当前实例上：

function UserAccount(username, rawPassword) {
  // 公开属性
  this.username = username;

  // 私有变量：外部代码无法直接获取 hash
  let _passwordHash = "hash_" + rawPassword.split("").reverse().join("");

  // 特权方法：绑定在实例上，可以访问构造函数作用域内的 _passwordHash
  this.verifyPassword = function(inputPassword) {
    const targetHash = "hash_" + inputPassword.split("").reverse().join("");
    return _passwordHash === targetHash;
  };

  this.updatePassword = function(oldPwd, newPwd) {
    if (!this.verifyPassword(oldPwd)) {
      throw new Error("旧密码验证不通过");
    }
    _passwordHash = "hash_" + newPwd.split("").reverse().join("");
    return true;
  };
}

// 原型方法：无须访问私有变量的通用逻辑，共享在原型链上
UserAccount.prototype.describe = function() {
  return `用户: ${this.username}`;
};

const user1 = new UserAccount("developer_tom", "secret123");
console.log(user1.describe());                     // 示例输出: 用户: developer_tom
console.log(user1.verifyPassword("secret123"));    // 示例输出: true
console.log(user1._passwordHash);                  // 示例输出: undefined

四、关键注意事项与常见陷阱排查

利用闭包封装私有变量时，如果不注意引用传递和生命周期细节，可能会引发数据泄漏或内存问题。开发中需要注意以下三个核心陷阱：

1. 警惕引用类型逃逸（引用泄漏）

如果私有变量是复合类型（如数组或对象），特权方法在提供读取访问时，切忌直接返回该变量的原始引用。在 JavaScript 中对象和数组按引用传递，如果直接返回原对象，调用者就能直接修改其内部属性，从而完全击穿封装性：

// 错误示例：直接返回内部数组引用（发生数据逃逸）
function createVulnerableStore() {
  const _items = ["item1", "item2"];
  return {
    getItems() {
      return _items; // 危险！返回了私有变量在堆中的原始地址
    }
  };
}

const store = createVulnerableStore();
const leakedList = store.getItems();
leakedList.length = 0; // 外部直接清空了内部私有数组！

// 正确示例：返回浅拷贝或深拷贝
function createSecureStore() {
  const _items = ["item1", "item2"];
  return {
    getItems() {
      // 使用扩展运算符返回浅拷贝数组，断开直接引用
      return [..._items];
      // 深度嵌套对象可使用 structuredClone(_items)
    }
  };
}

2. 内存生命周期管理与垃圾回收

闭包会导致外部函数的整个活动对象（词法环境）常驻在堆内存中。只要接收该特权方法的外部变量依然存活，垃圾回收器就永远不会释放这些私有变量所占用的内存。

如果在一个常驻全局或单页应用（SPA）中高频创建闭包对象而从不清理，极易造成隐蔽的内存泄漏。因此，当实例生命周期结束时，应主动显式解绑：

// 实例使用完毕，解除引用让 GC 正常回收闭包环境
let accountSession = createBankAccount("TempUser", 100);
// ... 业务操作完成后 ...
accountSession = null; // 切断与闭包特权方法的强引用链

3. 实例规模与性能权衡：闭包 vs ES2022 原生私有字段

在工厂函数与构造函数特权方法中，每个新实例都会在堆中重新生成一套完全独立的特权函数对象。如果有 10 万个账户实例，内存中就会存在 10 万份 deposit 函数对象，而无法像原型方法那样由所有实例共享一份代码。

因此，在编写通用工具模块、单例配置中心或普通业务对象时，利用函数作用域和闭包封装是最自然、最灵活的选择；而在需要承载百万级高频实体对象的面向对象系统中，可结合现代类的 #private 原生字段与原型共享来优化内存开销。