TypeScript：接受 map 到特定类型的所有 Object 密钥

Question

给定一个 object 类型（或 class 类型），我想写一个 function 接受 ZA8CFDE6331BD4C6EB2AC96F14 和 a9 的列表。 但是，我只想允许将 map 的键设置为特定类型的值，例如仅字符串。

例子：

function shouldOnlyAcceptStringValues(o, key) {
    // Do something with o[key] that depends on the assumption that o[key] has a specific type, e.g. string
}

const obj = {
    a: 1,
    b: "test",
    c: "bla"
}

const key = "c" as const;
shouldOnlyAcceptStringValues(obj, key);  // b and c should be accepted as keys, a not.

我知道一种强制key实际存在于o上的方法（无论o[key]的类型如何）：

function shouldOnlyAcceptStringValues<T>(o: T, key: keyof T) {
    // Do something with o[key] that depends on the assumption that o[key] has a specific type, e.g. string
}

但是，这也将允许使用key="a"尽管它映射到一个数字。

我需要的是这样的：

function shouldOnlyAcceptStringValues<T, K extends keyof T, T[K] extends string>(o: T, key: K)

但这当然不是有效的 TypeScript 代码。

有什么诀窍可以让它发挥作用吗？ 我需要一种方法来进一步细化键集keyof T 。 function 的主体应该知道o[key]是一个字符串，而无需明确检查 function 中的类型。 这有可能吗？

Answer 1

如果您想要从调用者的角度和实施者的角度都有效的东西，您可以这样做：

function shouldOnlyAcceptStringValues<K extends PropertyKey>(
  o: Record<K, string>, key: K
) {
    const okay: string = o[key];
}

这有点向后看你的约束； 不是将key限制为obj的正确键，而是将obj限制为 object ，其key处的值类型是string 。 您可以看到okay被接受为string ，并且在调用方方面也可以正常工作：

shouldOnlyAcceptStringValues(obj, "a"); // error!
// ------------------------> ~~~
// Argument of type '{ a: number; b: string; c: string; }' is 
// not assignable to parameter of type 'Record<"a", string>'.

shouldOnlyAcceptStringValues(obj, "b"); // okay
shouldOnlyAcceptStringValues(obj, "c"); // okay

唯一的障碍是第一次调用的错误可能不在您期望的参数上； 它在抱怨obj而不是"a" 。 如果没问题，那就太好了。 如果不是，那么您可以将调用签名更改为您正在谈论的那种约束：

---

type KeysMatching<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T]
function shouldOnlyAcceptStringValues2<T>(o: T, key: KeysMatching<T, string>): void;
function shouldOnlyAcceptStringValues2<K extends PropertyKey>(
  o: Record<K, string>, key: K
) {
    const okay: string = o[key];
}

KeysMatching<T, V>类型 function 采用类型T并仅返回其值可分配给V的那些键。 因此，调用签名将为o指定T ，为key指定KeysMatching<T, string> 。 请注意我是如何将该调用签名编写为单个重载的，并且实现签名与以前相同。 如果您不这样做，那么编译器将无法理解对于通用T而言T[KeysMatching<T, string>]可分配给string ； 这是编译器无法进行的高阶类型推断：

function shouldOnlyAcceptStringValuesOops<T>(o: T, key: KeysMatching<T, string>) {
    const oops: string = o[key]; // error!
    // -> ~~~~
    // Type 'T[{ [K in keyof T]: T[K] extends string ? K : never; }[keyof T]]' 
    // is not assignable to type 'string'. 😭
}

所以在重载版本中，我们让调用者看到key的约束，让实现看到obj的约束，这对每个人都更好：

shouldOnlyAcceptStringValues2(obj, "a"); // error!
// ------------------------------> ~~~
// Argument of type '"a"' is not assignable to parameter of type '"b" | "c"'

shouldOnlyAcceptStringValues2(obj, "b"); // okay
shouldOnlyAcceptStringValues2(obj, "c"); // okay

现在编译器抱怨key而不是obj 。

---

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

Playground 代码链接