在 TypeScript 中，如何获取值属于给定类型的对象类型的键？

Question

我一直在尝试创建一个由 T 类型的键组成的类型，其值为字符串。在伪代码中，它将是 keyof T where T[P] is a string。

我能想到的唯一方法是分两步：

// a mapped type that filters out properties that aren't strings via a conditional type
type StringValueKeys<T> = { [P in keyof T]: T[P] extends string ? T[P] : never };

// all keys of the above type
type Key<T> = keyof StringValueKeys<T>;

但是 TS 编译器说 Key<T> 简单地等于 keyof T，尽管我已经通过使用条件类型将它们设置为 never 过滤掉了值不是字符串的键。

所以它仍然允许这样做，例如：

interface Thing {
    id: string;
    price: number;
    other: { stuff: boolean };
}

const key: Key<Thing> = 'other';

当key 的唯一允许值确实应该是"id"，而不是"id" | "price" | "other"，因为其他两个键的值不是字符串。

Link to a code sample in the TypeScript playground

Answer 1

这可以通过conditional types 和indexed access types 完成，如下所示：

type KeysMatching<T, V> = {[K in keyof T]-?: T[K] extends V ? K : never}[keyof T];

然后你像这样拉出属性匹配string的键：

const key: KeysMatching<Thing, string> = 'other'; // ERROR!
// '"other"' is not assignable to type '"id"'

详细说明：

KeysMatching<Thing, string> ➡

{[K in keyof Thing]-?: Thing[K] extends string ? K : never}[keyof Thing] ➡

{ 
  id: string extends string ? 'id' : never; 
  price: number extends string ? 'number' : never;
  other: { stuff: boolean } extends string ? 'other' : never;
}['id'|'price'|'other'] ➡

{ id: 'id', price: never, other: never }['id' | 'price' | 'other'] ➡

'id' | never | never ➡

'id'

---

注意你在做什么：

type SetNonStringToNever<T> = { [P in keyof T]: T[P] extends string ? T[P] : never };

实际上只是将非字符串属性 values 转换为 never 属性值。它没有触摸按键。您的 Thing 将变为 {id: string, price: never, other: never}。其中的键与Thing 的键相同。与 KeysMatching 的主要区别在于您应该选择键，而不是值（所以 P 而不是 T[P]）。

Playground link to code

Answer 2

作为补充回答：

从 4.1 版开始，您可以利用 key remapping 作为替代解决方案（请注意，核心逻辑与 jcalz 的 answer 没有区别）。只需过滤掉用于索引源类型时不生成可分配给目标类型的类型的键，然后提取剩余键与 keyof 的联合：

type KeysWithValsOfType<T,V> = keyof { [ P in keyof T as T[P] extends V ? P : never ] : P };

interface Thing {
    id: string;
    price: number;
    test: number;
    other: { stuff: boolean };
}

type keys1 = KeysWithValsOfType<Thing, string>; //id -> ok
type keys2 = KeysWithValsOfType<Thing, number>; //price|test -> ok

Playground

---

正如Michal Minich 正确提到的：

两者都可以提取字符串键的并集。然而，当它们应该用于更复杂的情况时——比如 T extends Keys... 那么 TS 不能很好地“理解”你的解决方案。

由于上述类型不使用keyof T 进行索引，而是使用映射类型的keyof，因此编译器无法推断T 可以被输出联合索引。为了确保编译器能够做到这一点，可以将后者与keyof T 相交：

type KeysWithValsOfType<T,V> = keyof { [ P in keyof T as T[P] extends V ? P : never ] : P } & keyof T;

function getNumValueC<T, K extends KeysWithValsOfType<T, number>>(thing: T, key: K) {
    return thing[key]; //OK
}

Updated Playground