Typescript 如何从泛型类扩展？

现在我有三门课，

A

，

B

和

C

B

扩展自

A

C

可以从

A

扩展，也可以从

B

扩展

如何为C类编写代码

是否有类似于：

class C extends <T>{...}

类C扩展了{…}

T

将仅为

A

或

B

。它是

A

还是

B

取决于编译时

是否有类似

类C扩展{…}

不，没有

您可以创建

CA扩展A

和

CB扩展CB

，并在运行时在两者之间进行选择 是否有类似

类C扩展{…}

不，没有

---

您可以创建

CA扩展A

和

CB扩展CB

，并在运行时在两者之间进行选择您不能使用泛型。您可以使用类似于的模式来实现这一点，但它相当复杂，需要您在单独的接口中描述

C

将添加到

a

或

B

的类，然后使用a或B作为参数来构造和返回类定义的函数。您还必须为该函数提供两个单独的重载声明，因为基本上不可能声明扩展类以外的任何内容的类-您不能为此使用union type

a | B

class A { a: string }

class B extends A { b: string }

interface C_only { // decsribes what C will add to either A or B
    c: number;
}

interface C_extended_from_A {
    new (): C_only & A;
}
interface C_extended_from_B {
    new (): C_only & B;
}

function extend_A_or_B(Base: typeof B): C_extended_from_B;
function extend_A_or_B(Base: typeof A): C_extended_from_A;
function extend_A_or_B(Base: typeof A): typeof A {
    return class C extends Base implements C_only {
        constructor() {
            super();
    // can access only methods from common base class A in the implementation
            this.c = this.a.length;
        }

        c: number;
    }
}

const CA = extend_A_or_B(A);
const CB = extend_A_or_B(B);

const ca = new CA();
const cb = new CB();


const a1 = ca.a;
//const b1 = ca.b // error - no b here 
const c1 = ca.c;

const a2 = cb.a;
const b2 = cb.b;
const c2 = cb.c;

---

不确定它是否解决了您的问题，或者是否值得拥有这样的复杂性，但这就是问题所在。

您不能使用泛型。您可以使用类似于的模式来实现这一点，但它相当复杂，需要您在单独的接口中描述

C

将添加到

a

或

B

的类，然后使用a或B作为参数来构造和返回类定义的函数。您还必须为该函数提供两个单独的重载声明，因为基本上不可能声明扩展类以外的任何内容的类-您不能为此使用union type

a | B

class A { a: string }

class B extends A { b: string }

interface C_only { // decsribes what C will add to either A or B
    c: number;
}

interface C_extended_from_A {
    new (): C_only & A;
}
interface C_extended_from_B {
    new (): C_only & B;
}

function extend_A_or_B(Base: typeof B): C_extended_from_B;
function extend_A_or_B(Base: typeof A): C_extended_from_A;
function extend_A_or_B(Base: typeof A): typeof A {
    return class C extends Base implements C_only {
        constructor() {
            super();
    // can access only methods from common base class A in the implementation
            this.c = this.a.length;
        }

        c: number;
    }
}

const CA = extend_A_or_B(A);
const CB = extend_A_or_B(B);

const ca = new CA();
const cb = new CB();


const a1 = ca.a;
//const b1 = ca.b // error - no b here 
const c1 = ca.c;

const a2 = cb.a;
const b2 = cb.b;
const c2 = cb.c;

---

不确定它是否解决了您的问题，或者是否值得拥有这样的复杂性，但事实就是如此。

是否在运行时决定C是扩展A还是扩展B？是否有可能只制作两个版本的C，一个扩展A，另一个扩展B？然后你就可以根据你的运行时限制来构造正确的一个。如果你给出一个你想如何使用

C

的例子也会有所帮助——一个你想在什么时候使用

C

在哪里扩展

B

，另一个使用

C

在哪里扩展

A

的例子。基本上，你不能这样做。为什么要这样做？是否在运行时决定C是扩展A还是扩展B？是否有可能只制作两个版本的C，一个扩展A，另一个扩展B？然后你就可以根据你的运行时限制来构造正确的一个。如果你给出一个你想如何使用

C

的例子也会有所帮助——一个你想在什么时候使用

C

在哪里扩展

B

，另一个使用

C

在哪里扩展

A

的例子。基本上，你不能这样做。你为什么要这么做？