Question

我正在努力更好地理解类型感染规则，我有一个让人困扰的人为例子：

设置：

interface Model{
    label?: string;
}

interface View<T>{
    cid?: string;
    model?: T;
}

class Foo {
    findWithModel<TModel extends Model, TView extends View<TModel>>(value: TModel): TView;
    findWithModel(value: string): any {
        return {cid: "2"};
    }
}

class AModel implements Model{
    constructor(public label: string){}
}

class AView<T extends Model> implements View<T>{
    cid = "1";
    model = null;
}

let f = new Foo();
let model = new AModel("test");

所以我有一个重载findWithModel，在一种情况下它会返回any而另一种情况下它应该有效地返回SomeView<SomeModel>，问题如下：

let trial1 = f.findWithModel<AView<AModel>, AModel>(model);
let trial2: AView<AModel> = f.findWithModel(model);

所以trial1，这是有效的，但显然对于为什么这么麻烦，这是非常冗长的。似乎需要额外的工作来传递AModel 2x

所以我假设，你知道我应该能够提供关于结果声明的类型信息，trial2但是typescript会将其视为：

Foo.findWithModel<AModel, {}>(value: AModel): {}

这显然失败了：

Property 'cid' is missing in type '{}'

如果我没有通过AModel 2x 的过于冗长的调用，这是否可以实现？

Answer 1

如果你不介意回到View<T>而不是你在通用约束中传递的更具体的类型，那么你可以这样做：

findWithModel<TModel extends Model>(value: TModel): View<TModel> {
    ...
}

let trial1 = f.findWithModel(model); // type of trail1 is View<AModel>

如何正确地将相关类型分配给方法

1 个答案: