打字稿中的类构造函数类型？

Question

如何声明class 类型，以确保对象是通用类的构造函数？

在下面的示例中，我想知道应该给AnimalClass 提供哪种类型，以便它可以是Penguin 或Lion：

class Animal {
    constructor() {
        console.log("Animal");
    }
}

class Penguin extends Animal {
    constructor() {
        super();
        console.log("Penguin");
    }
}

class Lion extends Animal {
    constructor() {
        super();
        console.log("Lion");
    }
}

class Zoo {
    AnimalClass: class // AnimalClass could be 'Lion' or 'Penguin'

    constructor(AnimalClass: class) {
        this.AnimalClass = AnimalClass
        let Hector = new AnimalClass();
    }
}

当然class类型不行，反正也太笼统了。

Answer 1

编辑：这个问题在 2016 年得到了回答，有点过时了。查看下面的@Nenad 最新答案。

来自typescript interfaces reference的解决方案：

interface ClockConstructor {
    new (hour: number, minute: number): ClockInterface;
}
interface ClockInterface {
    tick();
}

function createClock(ctor: ClockConstructor, hour: number, minute: number): ClockInterface {
    return new ctor(hour, minute);
}

class DigitalClock implements ClockInterface {
    constructor(h: number, m: number) { }
    tick() {
        console.log("beep beep");
    }
}
class AnalogClock implements ClockInterface {
    constructor(h: number, m: number) { }
    tick() {
        console.log("tick tock");
    }
}

let digital = createClock(DigitalClock, 12, 17);
let analog = createClock(AnalogClock, 7, 32);

所以前面的例子变成了：

interface AnimalConstructor {
    new (): Animal;
}

class Animal {
    constructor() {
        console.log("Animal");
    }
}

class Penguin extends Animal {
    constructor() {
        super();
        console.log("Penguin");
    }
}

class Lion extends Animal {
    constructor() {
        super();
        console.log("Lion");
    }
}

class Zoo {
    AnimalClass: AnimalConstructor // AnimalClass can be 'Lion' or 'Penguin'
    
    constructor(AnimalClass: AnimalConstructor) {
        this.AnimalClass = AnimalClass
        let Hector = new AnimalClass();
    }
}

Answer 2

像这样：

class Zoo {
    AnimalClass: typeof Animal;

    constructor(AnimalClass: typeof Animal ) {
        this.AnimalClass = AnimalClass
        let Hector = new AnimalClass();
    }
}

或者只是：

class Zoo {
    constructor(public AnimalClass: typeof Animal ) {
        let Hector = new AnimalClass();
    }
}

typeof Class 是类构造函数的类型。它比自定义构造函数类型声明更可取，因为它可以正确处理静态类成员。

这是TypeScript docs 的相关部分。搜索typeof。作为 TypeScript 类型注释的一部分，它的意思是“给我一个叫做 Animal 的符号的类型”，在我们的例子中，它是类构造函数的类型。

Answer 3

如何声明一个类类型，以确保对象是一个通用类的构造函数？

构造函数类型可以定义为：

 type AConstructorTypeOf<T> = new (...args:any[]) => T;

 class A { ... }

 function factory(Ctor: AConstructorTypeOf<A>){
   return new Ctor();
 }

const aInstance = factory(A);

Answer 4

当最初提出问题时，我不确定在 TypeScript 中这是否可行，但我首选的解决方案是使用 generics：

class Zoo<T extends Animal> {
    constructor(public readonly AnimalClass: new () => T) {
    }
}

即使在 TypeScript 智能感知中，变量 penguin 和 lion 也可以推断出具体类型 Penguin 或 Lion。

const penguinZoo = new Zoo(Penguin);
const penguin = new penguinZoo.AnimalClass(); // `penguin` is of `Penguin` type.

const lionZoo = new Zoo(Lion);
const lion = new lionZoo.AnimalClass(); // `lion` is `Lion` type.