Question

我正在努力编写一个代码来推断args.value范围内if的类型：

class Foo {
    public id: number;
    public name: string;
    public birth: Date;
}

interface ISetEventArgs<T> {
    field: keyof T;
    value: T[keyof T];
}

function bind<T>(obj: T, event: "set", handler: (args: ISetEventArgs<T>) => void): void {
    // Void
}

let f: Foo = new Foo();

bind<Foo>(f, "set", (args: IArgs<Foo>): void => {
    if (args.field === "id") {
        let id: number = args.value; // Error: Type 'string | number | Date' is not assignable to type 'number'.
    }
    else if (args.field === "name") {
        // ...
    }
    else if (args.field === "birth") {
        // ...
    }
});

我试图通过写这样的东西来解决这个问题，但感觉不对：

function getValue<T, K extends keyof T>(value: T[keyof T], key: K): T[K] {
    return value;
}

// Usage:
if (args.field === "id") {
    let id: number = getValue<Foo, "id">(args.value, args.field); // Correct type.
    // Can also be used as: getValue<Foo, "id">(args.value, "id");
}

有什么想法吗？即使解决方案需要使用辅助函数，我也希望能够以更干净的方式使用它，例如（如果可能）getValue<Foo, "id">(args.value)或getValue(args.value, args.field)

Answer 1

我不认为没有帮助函数就可以做到 - 打字稿类型推断没有考虑到field和value的类型是相互依赖的。

所以你必须使用所谓的user-defined type guard function来明确表达类型关系：

class Foo {
    public id: number;
    public name: string;
    public birth: Date;
}

interface ISetEventArgs<T> {
    field: keyof T;
    value: T[keyof T];
}

function bind<T>(obj: T, event: "set", handler: (args: ISetEventArgs<T>) => void): void {
    // Void
}

let f: Foo = new Foo();

// type guard
function argsForField<T, F extends keyof T>(args: ISetEventArgs<T>, field: F):
         args is { field: F; value: T[F]} {
    return args.field === field;
}

bind<Foo>(f, "set", (args: ISetEventArgs<Foo>): void => {
    if (argsForField(args, "id")) {
        let id: number = args.value; //no error
    }
    else if (argsForField(args, "name")) {
        let name: string = args.value
    }
    else if (argsForField(args, "birth")) {
        let birth: Date = args.value;
    }
});

Answer 2

这个问题一直困扰着我，所以我玩弄了它，虽然我没有解决方案（遗憾的是），但我确实发现了一些有趣或可能没有帮助的行为，取决于您的确切用例。

TL; DR：你可以在Foo的特定情况下获得你想要的东西，但不是一般的。这似乎是打字稿部分的限制。

首先，让我们将ISetEventArgs的字段和值绑定在一起：

interface ISetEventArgs<T, K extends keyof T> {
    field: K;
    value: T[K];
}

现在，问题是类型：

ISetEventArgs<Foo, keyof Foo>

解析为：

ISetEventArgs<Foo, "id"|"name|"birth">

但我们希望它是：

ISetEventArgs<Foo, "id"> | ISetEventArgs<Foo, "name"> | ISetEventArgs<Foo, "birth">

因为在第二种情况下，我们可以利用打字稿的歧视联盟能力。在我看来，这些在语义上是相同的，但打字稿只会缩小第二种情况。所以我们需要做一些类型的恶作剧才能把它变成那种形式。

所以，如果我们定义一个类型：

type FooArgs = {[K in keyof Foo]: ISetEventArgs<Foo, K>}[keyof Foo]

然后解决了我们想要的......但遗憾的是，如果我们尝试扩展这种模式，那么它适用于任何类型：

type GenericArgs<T> = {[K in keyof T]: ISetEventArgs<T, K>}[keyof T];
type GenricFooArgs = GenericArgs<Foo>;

突然GenericFooArgs解析为上面的第一种类型，而不是第二种类型？！我不知道为什么手动声明FooArgs与使用GenericArgs<Foo>的方式不同。

因此，如果您使用FooArgs代替ISetEventArgs<T>，那么在实施处理程序时，您将获得所需的内容。但是......你已经失去了bind的通用能力，所以它毕竟不是一个有价值的交易。

使用泛型和keyof时，使用Deduce属性类型的回调参数

2 个答案: