Typescript 父类如何根据子类确定传递给方法的类型？

我正在尝试创建子类来处理应用程序不同区域的权限。每个子类都有一个它们处理的有效操作的不同列表，以及我们显示的不允许该操作的各种原因。我试图在父类上定义一个

hasPermissions

方法来检查权限是否已启用，但如果我传入的字符串对当前实例来说不是有效的操作，我希望它会抱怨

我知道我可以通过在每个子类上定义

haspowpermissions

来处理这个问题，即

haspowpermissions（actionName:UserActions）{…}

，但我希望避免这种情况。父类是否有一种方法可以基于当前实例确定允许哪些操作

declare var _;

type TPermission<TAction, TReason> = {
    action: TAction;
    enabled: boolean;
    reason?: TReason;
}

class Permissions {
    constructor(protected permissions) {
    }

    hasPermission(actionName) {
        let permission = _.find(this.permissions, {
            action: actionName
        });

        return permission ? permission.enabled : false;
    }
}

type AdminActions = 'Add User' | 'Delete User';
type AdminReasons = 'MaxUsersReached' | 'CantDeleteAnotherAdmin';
type TAdminPermission = TPermission<AdminActions, AdminReasons>;

class AdminPermissions extends Permissions {
    protected permissions: TAdminPermission[];

    constructor(permissions: TAdminPermission[]) {
        super(permissions);
    }
}

type UserActions = 'Subscribe' | 'Unsubscribe';
type UserReasons = 'AlreadySubscribed' | 'AlreadyUnsubscribed';
type TUserPermission = TPermission<UserActions, UserReasons>;

class UserPermissions extends Permissions {
    protected permissions: TUserPermission[];

    constructor(permissions: TUserPermission[]) {
        super(permissions);
    }
}

let permissions: TUserPermission[] = [
    {
        action: 'Subscribe',
        enabled: true
    }
];

let user = new UserPermissions(permissions);

user.hasPermission('Subscribe'); // Valid, should return true
user.hasPermission('Unsubscribe'); // Valid, should return false
user.hasPermission('Add User'); // Invalid permission for UserPermissions, should error

declarevar；
类型TPermission={
行动：战术；
启用：布尔值；
理由：叛国；
}
类权限{
构造函数（受保护的权限）{
}
hasPermission（actionName）{
let permission=\ u0.find（this.permissions{
动作：动作名称
});
返回权限？权限.已启用：false；
}
}
键入AdminActions='添加用户'|'删除用户'；
类型AdminReasons='MaxUsersReached'|'CantDeleteAnotherAdmin'；
类型TAdminPermission=TPermission；
类AdminPermissions扩展权限{
受保护的权限：TAdminPermission[]；
构造函数（权限：TAdminPermission[]）{
超级（权限）；
}
}
键入UserActions='Subscribe'|'Unsubscribe'；
键入UserReasons='AlreadySubscribed'|'AlreadyUnsubscribed'；
类型TUserPermission=tppermission；
类UserPermissions扩展权限{
受保护的权限：TUserPermission[]；
构造函数（权限：TUserPermission[]）{
超级（权限）；
}
}
let权限：TUserPermission[]=[
{
操作：'订阅'，
已启用：true
}
];
let user=new UserPermissions（权限）；
user.hasPermission（'Subscribe'）；//有效，应返回true
user.hasPermission（'Unsubscribe'）；//有效，应返回false
user.hasPermission（“添加用户”）；//UserPermissions的权限无效，应为错误

您可以将父类设置为泛型：

class Permissions<T extends string> {
    ...

    hasPermission(actionName: T) {
        ...
    }
}

说：

类型为“添加用户”的参数不能分配给类型为的参数 “用户操作”

如你所愿

---

（）

这太完美了！正是我想要的。

class AdminPermissions extends Permissions<AdminActions> { ... }

class UserPermissions extends Permissions<UserActions> { ... }

user.hasPermission('Add User');