基于泛型类型限制TypeScript类特定方法的访问权限

当前实现概述 #

你现在有一个泛型TypeScript类Lexicon，泛型约束为Dictionary（PublicDictionary和PersonalDictionary的联合类型），根据字典是公开还是私有，内部会初始化对应的操作集action。但目前的实现只能在运行时抛出错误，无法在编译阶段就限制不可用方法的访问，你想确认这个方案的可行性，以及如何实现更严格的类型检查。

现有核心代码 #

Lexicon类实现

export class Lexicon<T extends Dictionary> {
    private action: PublicDictionaryActions | PersonalDictionaryActions;
    
    constructor(private type: T) {
        this.type = type;
        this.action = type.isPublicResource
            ? initialisePublicActions()
            : initialisePersonalActions();
    }

    isPublicDictionary(type: Actions): type is PublicDictionaryActions {
        return this.type.isPublicResource;
    }

    saveWord(): boolean {
        if (this.isPublicDictionary(this.action) && "save" in this.action) {
            let isSaved = false
            this.action.save = () => {
                console.log("test save function");
                isSaved = true
            };
            this.action.save();
            return isSaved 
        } else {
            console.log();
            throw new Error("This method does not exist for the created type.")
        }
    }
    // rest of the methods follow... 
    
}

字典类型定义

export type PublicDictionary = {
    name: WordBook;
    isPublicResource: boolean;
    canShuffle: boolean;
    bannerImage?: string;
    wordList?: Array<Term>;
    apiKey?: string;
};

export type PersonalDictionary = {
    name: WordBook;
    isPublicResource: boolean;
    canShuffle: boolean;
    wordCount?: number;
    wordList?: Array<Term>;
};

export type Dictionary = PublicDictionary | PersonalDictionary;

操作类型定义

export type Actions = PublicDictionaryActions | PersonalDictionaryActions;

export type PublicDictionaryActions = Pick<IDictionary, "save" | "setCredentials" | "shuffle">;

export type PersonalDictionaryActions = Pick<IDictionary, "delete" | "update" | "shuffle">;

export interface IDictionary {
    update(): void;
    delete(): void;
    shuffle(): void;
    save(): void;
    shuffle(): void;
    setCredentials?(): void;
}

调用示例

const lexicon1 = new Lexicon<PublicDictionary>({...})
lexicon1.saveWord() // 正常执行

const lexicon2 = new Lexicon<PersonalDictionary>({...})
lexicon2.saveWord() // 运行时抛出错误

当前方案的可行性 #

这个方案运行时是可行的，但存在明显的类型安全缺陷：

• 编译阶段无限制：比如lexicon2.saveWord()在编译时不会报错，只有运行时才抛出错误，完全浪费了TypeScript的类型检查能力。
• 冗余检查：isPublicDictionary已经通过泛型的isPublicResource做了判断，但action的类型仍为联合类型，导致需要额外的"save" in this.action检查。
• 初始化逻辑混乱：saveWord方法里才给action.save赋值，不符合初始化的常规逻辑，应该在initialisePublicActions中完成。

优化方案：实现编译阶段严格检查 #

要让不可用方法从一开始就无法被访问，核心是利用TypeScript的条件类型或面向对象的子类拆分，让类的方法集与泛型类型严格绑定。

方案一：泛型条件约束类方法 #

通过条件类型动态控制类的可见方法，编译阶段直接屏蔽不匹配的方法。

步骤1：完善类型映射

// 字典类型到操作类型的映射
type DictionaryToActions<T extends Dictionary> = 
    T extends PublicDictionary ? PublicDictionaryActions : PersonalDictionaryActions;

// 定义不同字典对应的方法集
type PublicLexiconMethods = {
    saveWord(): boolean;
    setCredentials(): void;
    shuffle(): void;
};

type PersonalLexiconMethods = {
    deleteWord(): void;
    updateWord(): void;
    shuffle(): void;
};

// 动态选择方法集
type LexiconMethods<T extends Dictionary> = 
    T extends PublicDictionary ? PublicLexiconMethods : PersonalLexiconMethods;

步骤2：重构Lexicon类

export class Lexicon<T extends Dictionary> implements LexiconMethods<T> {
    private action: DictionaryToActions<T>;
    
    constructor(private type: T) {
        this.action = type.isPublicResource
            ? initialisePublicActions() as DictionaryToActions<T>
            : initialisePersonalActions() as DictionaryToActions<T>;
    }

    // 公开字典专属方法
    saveWord(): boolean {
        (this.action as PublicDictionaryActions).save();
        return true;
    }

    setCredentials(): void {
        (this.action as PublicDictionaryActions).setCredentials?.();
    }

    // 私有字典专属方法
    deleteWord(): void {
        (this.action as PersonalDictionaryActions).delete();
    }

    updateWord(): void {
        (this.action as PersonalDictionaryActions).update();
    }

    // 公共方法
    shuffle(): void {
        this.action.shuffle();
    }

    // 通过类型断言隐藏不匹配的方法，确保编译通过
    saveWord!: T extends PublicDictionary ? () => boolean : never;
    setCredentials!: T extends PublicDictionary ? () => void : never;
    deleteWord!: T extends PersonalDictionary ? () => void : never;
    updateWord!: T extends PersonalDictionary ? () => void : never;
}

步骤3：优化初始化函数

function initialisePublicActions(): PublicDictionaryActions {
    return {
        save: () => console.log("Public dictionary saved"),
        setCredentials: () => console.log("Credentials set"),
        shuffle: () => console.log("Public dictionary shuffled")
    };
}

function initialisePersonalActions(): PersonalDictionaryActions {
    return {
        delete: () => console.log("Word deleted"),
        update: () => console.log("Word updated"),
        shuffle: () => console.log("Personal dictionary shuffled")
    };
}

效果验证

现在编译阶段直接阻止错误调用：

const lexicon1 = new Lexicon<PublicDictionary>({
    name: "Test Public",
    isPublicResource: true,
    canShuffle: true
});
lexicon1.saveWord(); // 正常编译
lexicon1.deleteWord(); // 编译错误：属性'deleteWord'不存在于类型'Lexicon<PublicDictionary>'上

const lexicon2 = new Lexicon<PersonalDictionary>({
    name: "Test Personal",
    isPublicResource: false,
    canShuffle: true
});
lexicon2.deleteWord(); // 正常编译
lexicon2.saveWord(); // 编译错误：属性'saveWord'不存在于类型'Lexicon<PersonalDictionary>'上

方案二：子类拆分（更直观） #

如果觉得泛型条件过于复杂，可以用面向对象的子类拆分，直接为不同字典类型创建专属类：

// 基类定义公共方法
abstract class BaseLexicon {
    protected abstract action: Actions;

    shuffle(): void {
        this.action.shuffle();
    }
}

// 公开字典专属类
export class PublicLexicon extends BaseLexicon {
    protected action: PublicDictionaryActions;

    constructor(type: PublicDictionary) {
        super();
        this.action = initialisePublicActions();
    }

    saveWord(): boolean {
        this.action.save();
        return true;
    }

    setCredentials(): void {
        this.action.setCredentials?.();
    }
}

// 私有字典专属类
export class PersonalLexicon extends BaseLexicon {
    protected action: PersonalDictionaryActions;

    constructor(type: PersonalDictionary) {
        super();
        this.action = initialisePersonalActions();
    }

    deleteWord(): void {
        this.action.delete();
    }

    updateWord(): void {
        this.action.update();
    }
}

使用方式

const publicLexicon = new PublicLexicon({...});
publicLexicon.saveWord(); // 正常
publicLexicon.deleteWord(); // 编译错误

const personalLexicon = new PersonalLexicon({...});
personalLexicon.deleteWord(); // 正常
personalLexicon.saveWord(); // 编译错误

这种方式更符合常规面向对象设计，类型检查直观，代码维护成本更低。

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