TypeScript:如何通过一系列链式函数传递缩小类型？

Question

我有一系列链式函数，我想通过它们基于嵌套键结构来缩小类型。下面的代码(没有嵌套函数)可以毫无问题地推断类型:

const Keys = <const> {
    'KeyOne': {
        'SubKey1': '...',
        'SubKey2': '...'
    },
    'KeyTwo': {
        'SubKey3': '...',
        'SubKey4': '...'
    }
}

type Key = keyof typeof Keys;
type SubKey<K extends Key> = keyof typeof Keys[K];

let keyOne : Key = 'KeyOne';
let subKeyOne : SubKey<typeof keyOne> = 'SubKey1';

但是，当我将此推断为一系列嵌套函数时，尝试将任何值传递给返回的(第二个)函数会导致错误 Argument of type 'string' is not assignable to parameter of type 'never'.

const Keys = <const> {
    'KeyOne': {
        'SubKey1': '...',
        'SubKey2': '...'
    },
    'KeyTwo': {
        'SubKey3': '...',
        'SubKey4': '...'
    }
}

type Key = keyof typeof Keys;
type SubKey<K extends Key> = keyof typeof Keys[K];

function foo(f: Key){
    return function bar(b: SubKey<typeof f>){
        //...etc.
    }
}

foo('KeyOne')('SubKey1') //Argument of type 'string' is not assignable to parameter of type 'never'.

如何通过每个嵌套函数传递类型信息？

Answer 1

您的 foo()函数有 f Key 类型的参数, 和 SubKey<Key>是 never .相反，您应该使用 foo() generic在类型参数中 K constrained至Key并拥有 f属于 K 类型.

第一:SubKey<Key>是 never :

type Oops = SubKey<Key> // never

那是因为 the keyof type operator是 contravariant在它操作的类型中。特别是， keyof (A | B)计算结果为 (keyof A) & (keyof B) , 所以唯一的键 keyof (A | B)将为您提供肯定存在于 A | B 类型值中的键.也就是说，您只会获得工会的每个成员共有的 key 。如果您不知道该对象是否具有这样的成员，则允许您访问该对象的成员不被认为是类型安全的。
在您的示例中， (typeof Keys)[Key]是以下联合类型:

type TypeofKeysKey = typeof Keys[Key];
/* type TypeofKeysKey = {
    readonly SubKey1: "...";
    readonly SubKey2: "...";
} | {
    readonly SubKey3: "...";
    readonly SubKey4: "...";
} */

由于该联合没有公用键， SubKey<Key>是 never .因此 bar()函数不能安全地接受任何输入。从某种意义上说，编译器无法区分

foo("KeyOne")

和

foo(Math.random() < 0.5 ? "KeyOne" : "KeyTwo")

当然，让后者接受任何输入都是危险的。如果我们想让编译器分辨这两个调用之间的区别，我们需要让它为 f 推断出更窄的类型。根据您传入的内容。

输入泛型:

function foo<K extends Key>(f: K) {
  return function bar(b: SubKey<K>) {
    //...etc.
  }
}

或者，取决于“等”的深度:

function foo2<K extends Key>(f: K) {
  return function bar<S extends SubKey<K>>(b: S) {
    return Keys[f][b];
  }
}

每当您可能关心选择了联合的哪个特定成员时，您应该考虑使用扩展所述联合的泛型类型参数。
让我们看看这是如何工作的:

foo('KeyOne')('SubKey1') // okay
foo('KeyTwo')('SubKey4') // okay
foo('KeyOne')('SubKey4') // error! 

好的!编译器现在对你很满意。当您调用 foo('KeyOne') ，编译器推断 "KeyOne"对于类型 K :

// function foo<"KeyOne">(f: "KeyOne"): (b: "SubKey1" | "SubKey2") => void

当您调用 foo('KeyTwo') , 它推断 "KeyTwo"对于类型 K :

// function foo<"KeyTwo">(f: "KeyTwo"): (b: "SubKey3" | "SubKey4") => void

并且在每种情况下，返回的函数都接受来自 typeof Keys 的选定属性的键。 .
Playground link to code