如何在TypeScript中编写其成员是给定类的子类的类型

Question

I would like to be able to say that a function only returns classes that extend some given class.

What I tried is to define a type AnimalClass

    interface AnimalClass {
        new( name : String ) : Animal ;
    }

I think this means that instances of AnimalClass are classes that have a constructor (or should I say "are a constructor") that takes a String and constructs an instance of Animal.

However the following code, which I think has an error, compiles with tsc version 1.7.5.

interface AnimalClass {
    new( name : String ) : Animal ;
}

abstract class Animal {
    name : String ;
    constructor( name : String ) { this.name = name } 
    abstract kind() : String ;
}

class Lion extends Animal {
    kind() : String { return "lion" ; }
}

function getAnimalClass() : AnimalClass {
    return Lion ;  //  Shouldn't this be an error?
}

function makeAnimal() : Animal {
    const klass = getAnimalClass() ;
    return new klass( "bob" ) ;
}

var a = makeAnimal() ;
console.log( a.name + " is a " + a.kind() ) ;

I think it is in error because in function getAnimalClass I need that Lion is an instance of AnimalClass , but Lion does not have a constructor that takes a String .

Perhaps Lion is inheriting the constructor from Animal . That would explain why there is no error and why the code runs and prints "bob is a lion"

But no! If I delete the constructor in Animal the code still compiles. (Although now it prints "undefined is a lion").

So main question is:

• How do I write a type that describes objects which are classes that extend a given class and provide a constructor with a given parameter list?

Secondary questions:

• Why does the above code not have an error?

• Are constructors inherited in TypeScript?

Answer 1

When you have methods backed by an interface that includes parameters, the callers will be required to pass an argument, but the callees are not required to use it.

So if the interface requires an argument to be passed, it is an error to omit it.

interface Example {
    (x: number): void;
}

var giveMeANumber: Example = function (num: number) {

}

giveMeANumber(); // Error

But it is not an error to ignore the argument that has been passed.

interface Example {
    (x: number): void;
}

var giveMeANumber: Example = function () {

}

giveMeANumber(15); // No Error

So in your case, you have defined that animals must be passed a string to their constructor. All animals must have a string passed - this is the common signature you have defined. In the case of lions, the string is ignored (because it isn't needed).

In your example, if you look at the generated code, you'll see that when you omit a constructor in a sub-class, one is generated for you:

function Lion() {
    _super.apply(this, arguments);
}

And it uses the magical arguments , which means the name does in fact make its way down to the base class. You can test this by serializing the lion:

var lion = new Lion('Clarence');
alert(JSON.stringify(lion));

If you added a constructor to your lion class, you would be told by the compiler that you need to call super in the constructor, and when that you have to pass a string to it:

class Lion extends Animal {
    constructor() {
        super('HARD-CODED');
    }

    kind() : String { return "lion" ; }
}

So your type is accurate, but TypeScript applies this information pragmatically, and with respect paid to JavaScript paradigms.

Answer 2

First of all, change the String types to be string . string is for the primitive type while String refers to the String interface.

Are constructors inherited in TypeScript?

Yes. You can do a quick test to see:

abstract class Animal {
    constructor(name: string) {}
}

class Lion extends Animal {
}

new Lion(); // error

How do I write a type that describes objects which are classes that extend a given class and provide a constructor with a given parameter list?

The way you are doing it is fine. It will always error for the return type specified in the new signature, which is sufficient for most scenarios. For example, passing it a class with a different structure from Animal will error.

As you've discovered though, it doesn't error in some scenarios and you've discovered one of them. It seems to not error when the return type of the new signature matches, but the number of parameters is different. That's why it doesn't error when you remove the constructor. Note though, that it will error if the return type matches, but at least one of the parameters has a different type.