索引访问类型

基本语法

索引访问类型看起来就像访问对象的属性，只不过发生在类型层面。用方括号 [] 从类型中”取出”某个属性的类型：

type Person = {
  name: string;
  age: number;
  alive: boolean;
};

type Age = Person["age"];         // number
type NameOrAge = Person["name" | "age"]; // string | number

Person["age"] 的结果是 number，和直觉一致。你也可以传入一个联合类型，一次性提取多个属性的类型。

T[keyof T]：获取所有属性类型的联合

索引访问和 keyof 的组合是最常见的模式。keyof T 返回所有键的联合，再用它去索引，就能拿到所有属性类型的联合：

type PersonValues = Person[keyof Person];
// string | number | boolean

这等同于把 Person 上所有属性的类型做了个”并集”。在工具类型里这个模式到处可见——比如实现 Pick 和 Omit 时的约束检查。

泛型联动：通用属性读取器

回到上一章的那个 getProperty 函数，这里 T[K] 的作用就清晰了：

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

const person: Person = { name: "李四", age: 25, alive: true };

const n: string = getProperty(person, "name"); // ✅ string
const a: number = getProperty(person, "age");   // ✅ number

T[K] 在这里是动态映射：K 是哪个键，返回类型就是哪个属性的类型。这就是泛型 + keyof + 索引访问类型三者联动的威力。

Arr[number]：提取数组元素类型

数组也是一种对象，它的键是数字。所以用 number 作为索引就能拿到数组元素的类型：

type StringArray = string[];
type Element = StringArray[number]; // string

type NumArr = number[];
type E2 = NumArr[number]; // number

从实际数组推导元素类型

typeof 和索引访问配合，可以不用手动声明就能拿到数组元素的完整类型：

const users = [
  { name: "Alice", age: 15 },
  { name: "Bob",   age: 23 },
  { name: "Eve",   age: 38 },
];

// 不用手写 interface User，类型自动推导
type User = typeof users[number];
// User = { name: string; age: number; }

type UserAge = typeof users[number]["age"]; // number

typeof users 拿到数组的类型，[number] 索引取元素类型。整个流程零重复声明，数组改了什么，类型就自动跟什么。

只能用类型做索引

注意：索引访问里的方括号必须用类型，不能用运行时变量：

const key = "age";
// type Bad = Person[key]; // ❌ key 是值，不是类型

// 要么用类型别名
type Key = "age";
type Good = Person[Key]; // ✅ number

// 要么用 typeof
type AlsoGood = Person[typeof key]; // ✅ number

小结

• T[K] 从对象类型中获取属性 K 的类型
• 联合类型做索引一次性提取多个属性的类型：T["a" | "b"]
• T[keyof T] 获取所有属性类型的联合
• Arr[number] 是提取数组元素类型的标准写法
• 索引必须是类型，不是运行时的值——需要时用 typeof