TypeScript:获取对象本身内部的对象键类型

Question

首先，抱歉标题不好。我真的不知道如何描述这个问题，也许这就是我还没有找到解决方案的原因!

这里有一个小片段展示了我的问题:

type Type<T> = {
  key: keyof T,
  doStuff: (value: T[typeof key]) => void
//                          ^^^
// TS2034: Cannot find name 'key'.
};

我想要做的事情非常简单(我希望如此)。我尝试过多次解决这个问题，但每次参数最终都是所有可用类型的联合。

const Test: Type<{ var1: string, var2: number }> = {
  key: 'var1',
  doStuff: (value) => {}
//          ^^^^^
// (parameter) value: string | number
};

如果有人能帮我解决这个问题，我将不胜感激。如果您需要有关我在这里尝试做什么或我已经尝试过的其他信息，请告诉我!

Answer 1

没有内置existential types在 TypeScript 中，所以你不能说“我不在乎 key 是哪个键，但它需要是 T 的 some 键”。

这样做的唯一方法是使 Type通用T和 K extends keyof T ，像这样:

type Type<T, K extends keyof T> = {
  key: K,
  doStuff: (value: T[K]) => void
};

那么你可以指定Test像这样:

const Test: Type<{ var1: string, var2: number }, "var1"> = {
  key: 'var1',
  doStuff: (value) => { } // value is inferred as string
}

这可行，但您可能对必须指定 "var1" 不满意手动输入类型和 key属性(property)。不幸的是，您不能只指定 T离开K待推断，at least for now .最终应该有办法拥有partial type argument inference ，可能尽快 August 2018, for TypeScript 3.1 .

现在你可以做一个涉及 currying 的解决方法。 ，其中泛型函数返回泛型函数。您指定一个，而将另一个留待推断。像这样:

const typeFor = <T>() => <K extends keyof T>(type: Type<T, K>) => type;

// T is specified manually
const typeForVar1StringVar2Number = typeFor<{ var1: string, var2: number }>();

// K is inferred from the argument
const Test2 = typeForVar1StringVar2Number({
  key: 'var1',
  doStuff: (value) => { } // value is inferred as string
});

这有点复杂，但它确实可以让您免于写出 'var1'对于 K .

好的，希望对您有所帮助。祝你好运!

---

编辑:我看到您确实需要存在类型，因为您需要这些东西的数组。当您有文字联合时(如 keyof T 如果 T 没有字符串索引)，获得类似存在的类型的一种方法是使用 distributive conditional types :

type PossibleTypes<T> = keyof T extends infer K ? 
  K extends any ? Type<T, K> : never : never;

PossibleTypes<T>成为所有 Type<T, K> 的联合体对于每个 K在 keyof T .让我们用它来制作这个数组:

type ArrayOfPossibleTypes<T> = Array<PossibleTypes<T>>
const asArrayOfPossibleTypes = <T>(arr: ArrayOfPossibleTypes<T>) => arr;
const testArray = asArrayOfPossibleTypes<{ var1: string, var2: number }>([
  {
    key: 'var1', doStuff(value) { /* value is string */ }
  }, {
    key: 'var2', doStuff(value) { /* value is number */ }
  }
]);

那里的推理看起来不错。如果您不太害怕分配条件类型，我会说这对您有用。

---

如果一切都失败了，TypeScript 中有一个存在类型的实现，但它涉及 continuation passing这对您的用例来说可能太多了。为了完整起见，我将为您提供一个示例:

type ExistentialType<T> = <R>(f: <K extends keyof T>(x: Type<T, K>) => R) => R;

不是说“我是 Type<T, K> 的某些 K ”，而是说“如果你给我一个在任何 Type<T, K> 上运行的函数，我可以为你调用该函数并给你结果”。让我们创建一个:

const exType: ExistentialType<{ var1: string, var2: number }> = 
  (f) => f({ key: 'var1', doStuff(value) { } });

然后使用它:

const obj = {var1: "hey", var2: 123};
exType(function (t) { if (t.doStuff) t.doStuff(obj[t.key]) });

这种由内而外的性质是古怪而有趣的，偶尔有用......但在这里可能有点过分了。

---

好的，希望 有所帮助。再次祝你好运。