怎么在JS构造器中定义私有变量和方法

在 JavaScript 中，要在构造器中定义外部无法直接读取或修改的私有变量和私有方法，核心路径有两种：一种是利用构造函数作用域与闭包，将数据保留在局部作用域并通过挂载在 this 上的特权方法访问；另一种是在现代 ES6+ 类规范中使用哈希前缀（#）原生私有字段与方法。本文通过具体场景与执行示例，完整讲解这两种主流方案的具体编写步骤、内存运作机制、边界验证方法及选型权衡。

一、基于构造函数与闭包的私有化（经典方案）

在传统函数构造器（Constructor Function）中，挂载到 this 上的属性与方法均为公有成员，任何代码持有实例引用后均可直接读写。要建立私有变量，关键在于利用 JavaScript 的函数作用域与闭包（Closure）。

做法是在构造函数体内使用 let 或 const 声明变量，使用普通函数声明创建私有方法。这些成员属于构造函数的局部作用域，外部无法穿透访问。若需向外提供操作能力，则在 this 上挂载能够访问这些局部成员的公开方法，这在面向对象设计中被称为“特权方法（Privileged Methods）”。

1. 完整实现代码

以一个银行账户管理场景为例，需要保护账户余额 balance 与内部审计方法 logTransaction：

function BankAccount(initialBalance) {
    // 1. 私有变量：仅在构造函数执行上下文内可见
    let balance = Number(initialBalance) || 0;

    // 2. 私有方法：外部无法直接调用
    function logTransaction(type, amount) {
        // 内部审计逻辑，例如写入格式化审计日志
        return `[审计] 交易类型: ${type}, 涉及金额: ${amount}, 剩余: ${balance}`;
    }

    // 3. 特权方法：挂载在 this 上，形成对 balance 和 logTransaction 的闭包
    this.deposit = function(amount) {
        if (typeof amount !== 'number' || amount <= 0) {
            throw new Error('存款金额必须为正数');
        }
        balance += amount;
        logTransaction('DEPOSIT', amount);
        return balance;
    };

    this.withdraw = function(amount) {
        if (typeof amount !== 'number' || amount <= 0) {
            throw new Error('取款金额必须为正数');
        }
        if (amount > balance) {
            throw new Error('账户余额不足');
        }
        balance -= amount;
        logTransaction('WITHDRAW', amount);
        return balance;
    };

    this.getBalance = function() {
        return balance;
    };
}

2. 运行结果与私有性验证

实例化并执行以下测试代码，验证外部访问界限：

const acc = new BankAccount(100);

// 执行特权方法
acc.deposit(50);
console.log(acc.getBalance()); // 输出示例: 150

// 尝试直接访问私有变量
console.log(acc.balance); // 输出示例: undefined

// 尝试直接调用私有方法
try {
    acc.logTransaction('TEST', 10);
} catch (e) {
    console.log(e.name); // 输出示例: TypeError (acc.logTransaction is not a function)
}

// 检查实例自身拥有的可枚举属性键
console.log(Object.keys(acc)); // 输出示例: ['deposit', 'withdraw', 'getBalance']

执行结果表明，balance 和 logTransaction 既没有出现在实例对象的属性集合中，也无法通过原型链访问，外部对其读取或篡改的路径被完全切断。

二、闭包私有方案的落地步骤与关键细节

通过构造函数闭包实现私有化是一个结构明确的过程，但必须严格遵循特定的定义与访问契约，以避免作用域逃逸或无意义的内存消耗。

关键注意事项：对象引用的泄漏风险

如果私有变量存储的是对象或数组等引用类型，特权方法在向外返回该数据时，必须提供深拷贝或特定标量，否则外部会通过引用直接篡改内部私有对象，破坏封装性。

三、进阶方案：使用 WeakMap 共享原型方法

闭包特权方法的主要瓶颈在于：无法共享原型方法。由于局部变量仅存在于构造函数的单次执行作用域中，定义在 BankAccount.prototype 上的函数完全无法触及这些局部变量。这意味着创建 10,000 个实例，就会在内存中生成 10,000 份相同的特权函数对象。

若既要保证数据的严格私有，又希望方法定义在原型链上以节省内存，可以使用模块作用域下的 WeakMap：

// 模块级或立即执行函数内的私有存储容器
const privateStore = new WeakMap();

function SecureAccount(owner, initialBalance) {
    // 将 this 作为键，私有数据作为值存入 WeakMap
    privateStore.set(this, {
        balance: Number(initialBalance) || 0,
        owner: String(owner)
    });
}

// 私有方法：模块内部普通函数，接收 this 提取私有数据
function internalAudit(instance, action) {
    const data = privateStore.get(instance);
    return `[审计] 用户 ${data.owner} 执行 ${action}`;
}

// 原型方法：所有实例共享同一函数对象，大幅节省内存
SecureAccount.prototype.deposit = function(amount) {
    const data = privateStore.get(this);
    if (!data) throw new TypeError('非法调用：无效实例');
    if (amount <= 0) throw new Error('金额错误');
    
    data.balance += amount;
    internalAudit(this, 'DEPOSIT');
    return data.balance;
};

SecureAccount.prototype.getBalance = function() {
    const data = privateStore.get(this);
    if (!data) throw new TypeError('非法调用：无效实例');
    return data.balance;
};

由于 WeakMap 的键是弱引用，当实例对象被外部垃圾回收时，其对应的私有数据也会自动被回收，不存在内存泄漏问题；同时 privateStore 对外部不可见，实现了真正的软硬件隔离。

四、现代规范：ES6+ Class 原生私有字段与方法（#语法）

在现代 JavaScript（ECMAScript 2022+）中，语言规范原生支持了以 # 为前缀的私有字段和私有方法。虽然它们在语法上声明在类体中，但其初始化时机与赋值逻辑完全发生在构造器（constructor）执行期。

1. 原生私有语法的标准写法

class ModernAccount {
    // 声明私有字段（在 constructor 执行时挂载私有命名空间）
    #balance;
    #transactionLogs = [];

    constructor(initialBalance) {
        // 在构造器内部为私有字段赋值
        this.#balance = Number(initialBalance) || 0;
    }

    // 原生私有方法：类外部完全不可见
    #record(type, amount) {
        this.#transactionLogs.push({ type, amount, time: Date.now() });
    }

    // 公开方法：内部可直接读写私有字段并调用私有方法
    deposit(amount) {
        if (amount <= 0) throw new Error('金额必须大于0');
        this.#balance += amount;
        this.#record('DEPOSIT', amount);
        return this.#balance;
    }

    getBalance() {
        return this.#balance;
    }

    // 检查字段是否存在（利用 in 操作符进行私有品牌检查）
    static checkAccount(obj) {
        return #balance in obj;
    }
}

2. 原生私有特性的核心防御

原生 # 语法属于“硬私有（Hard Private）”，其安全性远超过去的下划线约定（_name）或 Symbol 方案：

• 语法层拦截：在类外部直接编写 acc.#balance 会在编译/解析阶段直接抛出 SyntaxError: Private field '#balance' must be declared in an enclosing class。
• 反射无法穿透：Object.keys(acc)、Object.getOwnPropertyNames(acc)、Object.getOwnPropertySymbols(acc) 均无法提取该属性。
• 原型方法自然共享：deposit 和 getBalance 自动位于 ModernAccount.prototype 上，兼具内存共享与私有隔离。

五、工程选型与排查总结

在实际业务开发中，选择何种方式在构造器中定义私有成员，取决于运行环境的现代化程度以及当前类在生命周期中的实例化吞吐量：

核心排查与自检清单

1. 不要把 prototype 方法与构造函数局部变量混用： 如果采用构造函数闭包定义局部变量，切记在 Function.prototype 上定义的方法是无法越界访问这些变量的；必须通过 this.method = function() 在构造体内挂载特权方法。
2. 警惕特权方法中的 this 漂移： 如果特权方法被解构提取调用（例如 const { deposit } = account; deposit(100);），由于执行上下文变更，方法内部若依赖 this 可能会导致运行时报错。针对局部闭包变量本身不会受影响，但如果混用 this.#field 则需在构造器内显式调用 this.method = this.method.bind(this)。
3. 优先采用现代原生 # 语法： 在无需兼容过时环境的新项目中，始终优先使用 #field 和 #method()。这不仅是官方标准语法，还能让 JavaScript 虚拟机在 JIT 编译时做出更高效的字段偏移量优化，同时提供编译器层面的安全屏障。