Typescript 基于扩展类的接口的构造函数设置值

我有以下示例接口/类

export interface MyErrorI {
    something: boolean;
}

export class MyError extends Error implements MyErrorI {
    public something = false;

    constructor(message: string, key: keyof MyErrorI ) {
        super(message);

        this[key] = true; // this is the code that I want to reuse
    }
}

其概念是构造函数根据其键参数设置其属性的值

现在我想用另一个类来扩展它：

interface MyNewErrorI extends MyErrorI {
    somethingElse: boolean;
}

export class MyNewError extends MyError implements MyNewErrorI {
    public somethingElse = false;

    constructor(message: string, key: keyof MyNewErrorI) {
        super(message, key);
    }
}

现在，key参数可以具有扩展

MyErrorI

的接口属性。我不想将代码从父类的构造函数复制/粘贴到子类的构造函数，因为它在我的实际问题中很复杂

但是，上面的代码无法工作，因为

MyError

的构造函数需要一个键

MyErrorI

。但是，键

somethingElse

是

MyNewError

的有效属性

因此，问题是：父类的构造函数是否可能每次都基于调用

super

的子类访问

键

参数？

我尝试过这样做，但也没有成功：

export class MyError<T extends PaymentErrorI> extends Error implements MyErrorI {
    public something = false;

    constructor(message: string, key: keyof T) {
        super(message);

        this[key] = true;
    }
}

这将提供所需的功能。像这样，对于

err[key]=true

I get

Type'true'不能分配给Type'T[keyof T]'

---

提前谢谢

一个独立于构造函数的函数可能是可行的，因为构造函数不能覆盖预期的

this

类型，也不能使用特殊的

this

类型来引用正在构造的子类的类型，而仅仅为了键设置而添加类型参数将非常笨拙。函数签名的问题在于，您没有确保传入的

t

的键具有布尔值，因此将

true

指定给它们可能是无效的。函数定义应如下所示：

const setKeys = <K extends keyof any>(err: {[P in K]: boolean}, key: K | Array<K>) => {
    if (key instanceof Array) {
        key.forEach((v) => {
            err[v] = true;
        });
    } else {
        err[key] = true;
    }
};

---

我看不出明显的解决方案，但似乎不值得担心重用一行代码。你能给出一个更现实的例子吗？谢谢你的回答，我已经更新了这个问题，包括一个更现实的构造函数和一个潜在的替代方案

const setKeys = <T>(err: T, key: keyof T | Array<keyof T>)

const setKeys = <K extends keyof any>(err: {[P in K]: boolean}, key: K | Array<K>) => {
    if (key instanceof Array) {
        key.forEach((v) => {
            err[v] = true;
        });
    } else {
        err[key] = true;
    }
};

export class MyError extends Error implements MyErrorI {
    // ...
    setKeys<K extends keyof any>(this: { [P in K]: boolean }, key: K | Array<K>) { 
        if (key instanceof Array) {
            key.forEach((v) => {
                this[v] = true;
            });
        } else {
            this[key] = true;
        }
    }
}