Question

我试图让编译器推断并检查通用属性中的类型。我特别有：

type Args<T, O extends object> = {
    instance: O,
    key: { [K in keyof O]: T extends O[K] ? K : never }[keyof O]
};

class C<T> {
    public fn<O extends object>(args: Args<T, O>): void { }
}

Args是一个对象，并且是其键k之一，因此可以将T类型的内容分配给k。该类的用法如下：

type Test = { a: string, b: number };
let test: Test = { a: "", b: 2 };
let c = new C<string>();

c.fn({ instance: test, key: "a" }); // works, as expected
c.fn({ instance: test, key: "b" }); // error, as expected

这很好，因为可以推断类型参数O，检查key的类型，并在键入时建议key的所有可能性。

现在我想使用Args对象，该对象可以与C<T>.fn一起用作某些其他类的属性（出于注入目的），其中O的类型未知然而。但是类型检查失败，并显示any：

interface I<T> {
    args: Args<T, any>;
}

let i: I<string>;
i = { args: { instance: test, key: "b" } }; // no error

我尝试改用lambda：

interface I2<T> {
    args: <O extends object>() => Args<T, O>;
}

let i2: I2<string>;
i2 = { args: () => ({ instance: test, key: "a" }) }; //Type 'Test' is not assignable to type 'O'. ???
c.fn(i.args);

我不明白为什么会出现类型错误。

如何确保推断类型并检查接口的属性，就像它适用于通用函数一样？

Answer 1

因此，由于这是不可能的，一种实用的方法是使用强制执行类型约束的设置器或工厂。例如：

type Thing<T, A> = {
    a: A,
    b: SomeTypeDependingoOn<A>
};
class Factory<T> {
    public getThing<A, B extends SomeTypeDependingoOn<A>>(a: A, b: B): Thing<T, A>{
        return { a: a, b: b };
    }
}
let thing: Thing<string, any>;
thing = new Factory<string>().getThing(...); // type checking

推断属性中的泛型（例如在函数中）以进行正确的类型检查

1 个答案: