在 Typescript 中的 class 中扩展的类型是什么？

Question

Please can you clarify what is the meaning of this notation in Typescript and where to find documentation? Is typeA an alias of typeB? Does typeA extends also typeC and typeD? Does myClass "see" typeA inside itself? Thanks.

classe myClass<
    typeA extends typeB = Unknown
> extends anotherClass<
    typeC,
    typeD
>

Answer 1

What you are seeing here is a generic class which extends another generic class.

typeB , typeC , typeC , and Unknown are all known, pre-defined types. typeA is a variable. (The example could make that distinction a lot more clear.)

Does myClass "see" typeA inside itself?

Yes! myClass can use the type typeA for any of its methods or other internal typings.

Does typeA extends also typeC and typeD?

No. It might be true in some cases but it's not required. anotherClass has two generic variables. We are stating that our class myClass extends the version of anotherClass where those variables are set to typeC and typeD . Again, typeC and typeD are known types.

Is typeA an alias of typeB?

No, not always. Our variable typeA must extend the known type typeB . It could be typeB exactly or something that extends it. It is ok to use typeA anywhere that requires typeB since we know that typeA extends typeB .

Unknown is the fallback value for the variable typeA is no type can be inferred. Unknown must also extend typeB .

Hopefully this example makes it more clear:

// AnotherClass depends on two generics which could be anything
class AnotherClass<DataType, KeyType> {
    // the generics are used here to determine the types of the instance variables
    data: DataType;
    key: KeyType;

    // the generic values for each instance will be determined by the arguments which are passed to the constructor
    constructor(data: DataType, key: KeyType) {
        this.data = data;
        this.key = key;
    }
}

// MyInterface is some sort of known type
interface MyInterface {
    myKey: string;
}

// MyClass has one generics value Name which can be a specific string or just `string`
// it extends AnotherClass where `DataType` is `MyInterface` and `KeyType` is `string`
class MyClass<Name extends string = string> extends AnotherClass<MyInterface, string> {
    
    name: Name;

    constructor(name: Name, data: MyInterface) {
        // must call superclass AnotherClass's constructor
        super(data, name);
        
        this.name = name;
    }
}

Typescript Playground Link