从可区分联合数组中查找的窄返回类型

Question

我经常使用类似以下示例的代码，并且想知道是否有一些聪明的方法可以键入find结果而无需执行显式类型断言。

type Foo = { type: "Foo" };
type Goo = { type: "Goo" };
type Union = Foo | Goo;
const arr: Union[] = [];
const foo = arr.find(a => a.type === "Foo") as Foo;

如果省略as Foo类型断言，则结果为类型Union，即使它只能返回类型Foo。

在此类示例中，修复find类型以返回缩小类型的最干净方法是什么？

编辑：此问题也可能适用于filter和其他类似方法。

Edit2：建议的类似问题的接受答案(告诉TypeScript编译器Array.prototype.filter从数组中删除某些类型的方法？(表明，通过在谓词中使用类型保护来find/filter可以缩小返回值的范围。

如果区分字符串文字总是在键下，这个类型保护函数应该如何缩小任何可区分的联合type？

Answer 1

如果您希望用户定义的类型保护函数的生成器返回区分区分联合的类型谓词，它可能如下所示：

function discriminate<K extends PropertyKey, V extends string | number | boolean>(
discriminantKey: K, discriminantValue: V
) {
return <T extends Record<K, any>>(
obj: T & Record<K, V extends T[K] ? T[K] : V>
): obj is Extract<T, Record<K, V>> =>
obj[discriminantKey] === discriminantValue;
}

如果我调用discriminate("type", "Foo")，结果是一个签名类似于<T>(obj: T)=>obj is Extract<T, {type: "Foo"}>的函数。 (我说它类似，因为实际的返回值将T限制为仅将"type"作为键和可以"Foo"赋值的类型。 让我们看看它是如何工作的：

const foo = arr.find(discriminate("type", "Foo")); // Foo | undefined 
const goos = arr.filter(discriminate("type", "Goo"));  // Goo[]

看起来不错。 以下是如果您传递不适用的字段/值时会发生什么情况：

const mistake1 = arr.find(discriminate("hype", "Foo")); // error!
// ------------------->   ~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Union is not assignable to Record<"hype", any>.
const mistake2 = arr.find(discriminate("type", "Hoo")); // error!
// ------------------->   ~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Union is not assignable to ((Foo | Goo) & Record<"type", "Hoo">)

好的，希望有帮助;祝你好运！

链接到代码

Answer 2

这是上面答案中的jcalz代码，扩展了否定和并集。

export function isDiscriminate<K extends PropertyKey, V extends string | number | boolean>(
discriminantKey: K, discriminantValue: V | V[]
) {
return <T extends Record<K, any>>(
obj: T & Record<K, V extends T[K] ? T[K] : V>
): obj is Extract<T, Record<K, V>> =>
Array.isArray(discriminantValue) 
? discriminantValue.some(v => obj[discriminantKey] === v)
: obj[discriminantKey] === discriminantValue;
}
export function isNotDiscriminate<K extends PropertyKey, V extends string | number | boolean>(
discriminantKey: K, discriminantValue: V | V[]
) {
return <T extends Record<K, any>>(
obj: T & Record<K, V extends T[K] ? T[K] : V>
): obj is Exclude<T, Record<K, V>> =>
Array.isArray(discriminantValue)
? discriminantValue.some(v => obj[discriminantKey] === v)
: obj[discriminantKey] === discriminantValue;
}

和用法：

type A = { type: "A" };
type B = { type: "B" };
type C = { type: "C" };
type Union = A | B | C;
const arr: Union[] = [];
arr.find(isDiscriminate("type", "A")); // A
arr.find(isDiscriminate("type", ["A", "B"])); // A | B
arr.find(isNotDiscriminate("type", "A")); // B | C
arr.find(isNotDiscriminate("type", ["A", "B"])) // C

Answer 3

接受的答案非常好，但很难理解。我选择了这样的东西。它的可重用性较差，仅适用于一种类型，但更容易阅读。

function isType<V extends Union['type']>(val: V) {
return (obj: Union):
obj is Extract<Union, {type: V}> => obj.type === val;
}
const found = arr.find(isType('Foo'));

Answer 4

感谢jcalz的出色接受答案。

我为谓词守卫注释了一个稍微不同的工厂风格：

function hasProp<K extends PropertyKey, V extends string | number | boolean>(k: K, v: V) {

// All candidate types might have key `K` of any type
type Candidate = Partial<Record<K, any>> | null | undefined
// All matching subtypes of T must have key `K` equal value `V`
type Match<T extends Candidate> = Extract<T, Record<K, V>>
return <T extends Candidate>(obj: T): obj is Match<T> => (
obj?.[k] === v
)
}

Answer 5

到现在为止，我们可以将其作为一个合理的通用实用程序：

export function isOfType<
GenericType extends string,
Union extends { type: GenericType },
SpecificType extends GenericType,
>(val: SpecificType) {
return (obj: Union): obj is Extract<Union, { type: SpecificType }> =>
obj.type === val;
}
const found = arr.find(isOfType('Foo'));

灵感来自特雷弗·迪克森通过 https://stackoverflow.com/a/61102770