TypeScript泛型约束中的keyof T与T[K]的组合使用

TypeScript 的泛型非常强大，但许多开发者在处理对象属性时，经常会遇到类型无法自动推断或报错的情况。要解决这个问题，核心在于熟练掌握 keyof T 与 T[K] 的组合使用。这能让你编写出既能动态访问属性，又能保持严格类型安全的函数。

1. 理解 keyof T：锁定属性名范围

keyof T 是一个索引类型查询操作符，它的作用是将对象 T 的所有公共属性名提取出来，联合成一个字面量联合类型。

假设有一个用户接口：

interface User {
  id: number;
  name: string;
  isAdmin: boolean;
}

此时，keyof User 等价于 "id" | "name" | "isAdmin"。

定义一个简单的函数，尝试获取对象的属性：

function getValue(obj: T, key: string) {
  return obj[key];
}

这段代码在严格模式下会报错：Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'T'。

解决这个问题，使用 keyof T 对 key 参数进行约束。

修改代码如下：

function getValue<T, K extends keyof T>(obj: T, key: K) {
  return obj[key];
}

现在，K 必须是 T 的属性名之一。如果你传入一个不存在的属性名，TypeScript 会直接在编辑器中报错。

2. 理解 T[K]：获取属性值的类型

仅仅限制属性名是不够的，我们通常还需要精确知道获取到的值是什么类型。T[K] 就是所谓的“索引访问类型”，它代表了对象 T 中键为 K 的属性值的类型。

继续使用上面的 User 接口：

• User["id"] 的类型是 number。
• User["name"] 的类型是 string。
• User["isAdmin"] 的类型是 boolean。

当我们将 K extends keyof T 作为泛型约束时，T[K] 就能根据传入的动态键名，自动推断出返回值的类型。

编写一个带有明确返回类型的函数：

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

在这个函数签名中：

1. 输入 key 必须是 obj 的属性名。
2. 输出 类型完全取决于 key 对应的值类型。

3. 实战演练：构建类型安全的属性获取器

创建一个 User 对象并测试我们的 getProperty 函数。

const user: User = {
  id: 1001,
  name: "Alice",
  isAdmin: true
};

// 正确调用
const userId = getProperty(user, "id"); // userId 类型推断为 number
const userName = getProperty(user, "name"); // userName 类型推断为 string

// 错误调用（编译器会报错）
// const userAge = getProperty(user, "age"); // Error: Argument of type '"age"' is not assignable to parameter of type '"id" | "name" | "isAdmin"'.

观察上面的代码，你会发现 userId 被自动推断为 number，而无需手动声明类型。如果你尝试拼写错误的属性名，代码将无法编译。

4. 进阶应用：构建类型安全的属性修改器

除了获取属性，我们经常需要修改属性。为了保证类型安全，新值的类型必须与目标属性的类型完全一致。这里再次需要用到 T[K]。

定义一个 setProperty 函数：

function setProperty<T, K extends keyof T>(obj: T, key: K, value: T[K]) {
  obj[key] = value;
}

在这个定义中，value 参数的类型被限制为 T[K]。这意味着，如果你在修改 id 属性，TypeScript 会强制要求传入 number 类型的值。

测试修改逻辑：

const product = {
  title: "Laptop",
  price: 999,
  inStock: true
};

// 正确：price 是 number，传入 899
setProperty(product, "price", 899);

// 错误：price 是 number，不能传入字符串
// setProperty(product, "price", "Cheap"); // Error: Argument of type 'string' is not assignable to parameter of type 'number'.

// 错误：不存在 discount 属性
// setProperty(product, "discount", 0.1); // Error: Argument of type '"discount"' is not assignable to parameter of type '"title" | "price" | "inStock"'.

5. 处理可选属性与 undefined

在实际开发中，对象属性往往是可选的。如果 K 指向的是一个可选属性，T[K] 的类型会包含 undefined。

定义一个包含可选属性的接口：

interface Config {
  host: string;
  port: number;
  ssl?: boolean;
}

编写代码获取 ssl 属性：

const config: Config = { host: "localhost", port: 8080 };
const sslMode = getProperty(config, "ssl"); // 类型推断为 boolean | undefined

由于 ssl 可能不存在，sslMode 的类型是 boolean | undefined。在后续逻辑中，检查该值是否存在是必要的。

执行逻辑判断：

if (sslMode !== undefined) {
  // 在此代码块中，sslMode 的类型被收窄为 boolean
  console.log("SSL is enabled: " + sslMode);
}

6. 总结关键模式

为了方便查阅，下表总结了 keyof T 与 T[K] 组合使用的常见模式。

掌握 K extends keyof T 与 T[K] 的组合，是摆脱 any 类型、编写高健壮性 TypeScript 代码的关键一步。它让泛型不再只是抽象的占位符，而是能精确描述对象结构的工具。