TypeScript组合场景下私有成员共享的安全实现方案咨询

针对你遇到的「Manager需隐藏table方法但内部Element要调用」的问题，以下是几种可靠的替代方案：

方案1：模块封装 + 类型导出控制 #

把两个类放在同一模块文件中，通过类型限制只对外暴露需要的接口，内部类可以完整访问Manager的方法：

// 内部完整实现类
class ManagerImpl {
    run() {}
    table() {} // 仅内部可见的方法
}

class Element {
    parent: ManagerImpl;
    get() {
        this.parent.table(); // 内部正常调用
    }
}

// 对外只暴露run方法的类型
export type Manager = Pick<ManagerImpl, 'run'>;

// 对外返回被类型约束的实例
export function createManager(): Manager {
    return new ManagerImpl();
}

用户通过createManager拿到的实例只能调用run，完全看不到table方法，而内部的Element可以正常访问ManagerImpl的所有方法。

方案2：嵌套内部类 #

将Element定义为Manager的内部嵌套类，TypeScript允许嵌套类访问外部类的私有成员，同时外部用户无法访问私有方法：

class Manager {
    private table() {} // 真正私有，外部无法触及
    run() {}

    // 内部嵌套类，可直接访问外部类的private方法
    class Element {
        parent: Manager;
        get() {
            this.parent.table();
        }
    }

    // 可选：提供创建Element的工厂方法
    createElement(): Element {
        const elem = new this.Element();
        elem.parent = this;
        return elem;
    }
}

// 对外仅导出Manager
export { Manager };

这种方式下table是真正的私有成员，外部用户完全无法调用，内部Element则可以正常使用。

方案3：闭包封装 #

利用闭包把Manager和Element的实现包裹起来，只对外暴露指定接口：

const createManager = (() => {
    class Manager {
        run() {}
        table() {} // 闭包内可见，外部不可访问
    }

    class Element {
        parent: Manager;
        get() {
            this.parent.table();
        }
    }

    // 对外返回仅包含run方法的实例
    return () => {
        const manager = new Manager();
        // 可在此处理Element的关联逻辑
        return { run: manager.run.bind(manager) };
    };
})();

export { createManager };

闭包内部的所有细节都不会暴露给外部，只有createManager返回的run方法对外可见，Element可以自由访问Manager的内部方法。

方案4：模块级protected修饰符 #

TypeScript中，同模块内的类可以访问彼此的protected成员，外部则无法访问，适合不想改变类结构的场景：

// 同模块文件内
class Manager {
    protected table() {} // 模块内可见，外部不可见
    run() {}
}

class Element {
    parent: Manager;
    get() {
        this.parent.table(); // 同模块可直接调用
    }
}

// 对外导出Manager
export { Manager };

用户导入Manager后，无法调用table方法，而内部的Element可以正常访问。

内容的提问来源于stack exchange，提问作者parchii