“Barable”类型的参数不能分配给“T”类型的参数

Question

谁能解释一下，为什么这段代码不起作用：

class Fooable {
    foo: string;
}
class Barable extends Fooable { 
    bar: boolean;
}

function simplifiedExample<T extends Fooable>(): Array<T> {
    let list = new Array<T>();
        list.push(new Barable());
    return list;
}

Barable 正在扩展 Fooable。当 T 必须是 Fooable 时，为什么我不能将 Barable 添加到数组中？ 这里代码在playground

编辑：

问题是，simplifiedExample() 是基类的覆盖，基类只是一个定义。因为是一个混合项目 JS/TS。

见： new playground

我找到了一个带有演员表的解决方案，但对我来说这似乎不是一个合适的解决方案：

class BarableService extends FooableService { 

    simplifiedExample<T extends Fooable>(): Array<T> { 
        let list = new Array<Fooable>();
            list.push(new Barable());
        return list as Array<T>;
    }
}

Answer 1

虽然T 类型与Fooable 兼容，Barable 类型与Fooable 兼容，但这并不意味着Barable 与T 兼容。

例如：

class Bazable extends Fooable {
    baz: number;
}

const result: Bazable[] = simplifiedExample<Bazable>();

这让我想起了一点哲学，因为你可以看到这是不合逻辑的：

If T (Bazable) is a Fooable
And Barable is a Fooable
Then T (Bazable) is a Barable

或者……

If T (Lion) is a Cat
And Tiger is a cat
Then T (Lion) is a Tiger

     Cat
     / \
    /   \
Lion != Tiger

通用 vs 结构

由于结构类型系统，TypeScript 中有许多情况可以在没有泛型的情况下解决。您可能会发现，对您的 Barable 诚实就可以了：

function simplifiedExample(): Barable[] {
    let list: Barable[] = [];
    list.push(new Barable());
    return list;
}

除了兼容的结构之外，你不需要任何东西来通过类型检查：

class Bazable {
    foo: string;
    bar: boolean;
}

const a: Bazable[] = simplifiedExample(); 

甚至：

class Bazable {
    bar: boolean;
}

const a: Bazable[] = simplifiedExample(); 

当然还有：

const a: Fooable[] = simplifiedExample();

如果这不符合您的要求，您可能需要提供一个示例，说明您认为需要在何处引入泛型类型。通常，如果您想在函数中构造一个新的T，而不是固定类型。

Answer 2

正如@Fenton 指出的T 和Barable 的兼容性无法在函数中检查。如果需要创建T 的新实例，可以传入构造函数：

function simplifiedExample<T extends Fooable>(ctor: new ()=> T): Array<T> {
    let list = new Array<T>();
        list.push(new ctor());
    return list;
}

const result1: Bazable[] = simplifiedExample(Bazable);
const result2: Barable[] = simplifiedExample(Barable);

Answer 3

你的数组列表的类型是已知的，它应该是Fooable，因此返回类型。