我想得到一个像这样的 Narrowing 类型:
type Expected = {
method: 'firstNamespace/firstMethod'
payload: [string]
} | {
method: 'firstNamespace/secondMethod'
payload: [number, number]
} | {
method: 'secondNamespace/firstMethod'
payload: [number]
}
从这样的方法的对象:const Methods = {
firstNamespace: {
firstMethod: (p: string) => {},
secondMethod: (p: number, k: number) => {}
},
secondNamespace: {
firstMethod: (p: number) => {}
}
}
我尝试了各种方法,但我认为我在 TypeScript 中有一些误解。我已经使用 TypeScript 快一年了,任何超出基本类型的东西似乎都超出了我的能力范围......
最佳答案
这可以通过 recursive conditional types 在 TypeScript 中实现深入了解 Methods
的嵌套属性, 和 template literal types在类型级别将方法名称连接在一起。
我们将您要查找的类型函数称为 MethodsToExpected<T>
,它采用对象类型 T
并产生 union对象类型的 method
属性是 "/"
- 每个方法名称的分隔路径,其payload
属性是 tuple对应方法的参数类型。然后我们可以定义MethodsToExpected<T>
就自身而言,递归地是这样的:
type MethodsToExpected<T> = { [K in keyof T]-?:
T[K] extends (...args: infer P) => any ? { method: K, payload: P } :
MethodsToExpected<T[K]> extends infer X ? (
X extends { method: infer M, payload: infer P } ? (
{ method: `${Extract<K, string>}/${Extract<M, string>}`; payload: P }
) : never
) : never
}[keyof T]
施工{[K in keyof T]-?: XXX}[keyof T]
,立即indexes into一个 mapped type用它的键,产生所有 XXX
的联合类型。对于每个属性键
K
来自 T
,我们检查属性类型T[K]
.如果它是一个函数类型,那么我们获取它的参数列表并立即返回{method: K, payload: P}
.否则我们申请MethodsToExpected<T[K]>
到属性(property)并进行检查。(旁白:我正在使用 conditional type inference 将
MethodsToExpected<T[K]>
“复制”到新的类型参数 X
中,然后我将其用作 distributive conditional type 中的检查类型,以便 X
中的任何联合都分发到最终的联合。如果您只是使用 MethodsToExpected<T[K]> extends {method: infer M, payload: infer P}
而不是中间 X
,它将产生类似 {method: "a/b" | "a/c", payload: [string] | [number]}
而不是所需的 {method: "a/b", payload: [string]} | {method: "a/c", payload: [number]}
的东西。)对于
MethodsToExpected<T[K]>
的每个联合元素,我们拔出method
类型 M
和 payload
类型 P
, 并建立一个新的 method
/payload
一对。 payload
类型不会改变,只是 P
, 但我们在当前 key K
前面加上和斜线 "/"
到M
使用模板文字类型。编译器不能确定 K
和 M
都是string
类型,所以它不想让你写 `${K}/${M}`
直接地。相反,我们使用 the Extract<T, U>
utility type让编译器相信我们只会连接 string
s。让我们看看它是否有效:
type Expected = MethodsToExpected<typeof Methods>;
/* type Expected = {
method: "firstNamespace/firstMethod";
payload: [p: string];
} | {
method: "firstNamespace/secondMethod";
payload: [p: number, k: number];
} | {
method: "secondNamespace/firstMethod";
payload: [p: number];
} */
看起来不错。为了确保它深入到嵌套的子属性,让我们尝试一个不同的:type Nested = MethodsToExpected<{ a: { b: { c: { d: { e: (f: string) => number } } } } }>;
/* type Nested = {
method: "a/b/c/d/e";
payload: [f: string];
} */
也很好。Playground link to code
关于javascript - 从方法对象获取窄类型,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/69562731/