前言
TypeScript 的核心价值不是“给 JavaScript 加几个类型注释”，而是用类型系统提前描述数据结构、函数契约和业务状态。
这篇文章会从基础类型讲起，重点展开几个 TS 进阶高频点：
- 索引签名
[key: string]: unknown
-
in 类型收窄
-
extends 的多种用法
-
value is Xxx 类型守卫
-
object、Object、unknown、any 的区别
- 联合类型和交叉类型
- 函数重载
- 泛型
infer- 常用工具类型源码实现和使用场景
1. TypeScript 到底解决什么问题？
TypeScript = JavaScript + 静态类型检查。
它最终还是会编译成 JavaScript，类型只存在于编译期。
function add(a: number, b: number): number {
return a + b;
}
add(1, 2);
add("1", 2); // 报错
TS 的作用是：在代码运行前，提前发现类型错误。
2. 基础类型
常见基础类型：
let name: string = "Tom";
let age: number = 18;
let isAdmin: boolean = false;
let n: null = null;
let u: undefined = undefined;
let big: bigint = 100n;
let sym: symbol = Symbol("id");
数组：
const nums: number[] = [1, 2, 3];
const names: Array<string> = ["Tom", "Jerry"];
元组：
const user: [string, number] = ["Tom", 18];
对象：
const user: { id: string; name: string } = {
id: "001",
name: "Tom",
};
3. any、unknown、never、void
3.1 any
any 表示任意类型，但会关闭类型检查。
let value: any = "hello";
value.toFixed(); // TS 不报错，但运行可能报错
3.2 unknown
unknown 也可以接收任意类型，但使用前必须判断。
let value: unknown = "hello";
if (typeof value === "string") {
value.toUpperCase();
}
所以：
unknown = 类型安全版 any
3.3 void
void 常用于表示函数没有返回值。
function log(message: string): void {
console.log(message);
}
3.4 never
never 表示永远不会出现的值。
function fail(message: string): never {
throw new Error(message);
}
也常用于穷尽检查：
function assertNever(value: never): never {
throw new Error(`Unexpected value: ${value}`);
}
4. 索引签名：[key: string]: any
你可能见过这样的写法：
type Obj = {
[props: string]: any;
};
它表示：
这个对象可以有任意字符串 key，并且 value 是 any 类型。
props 只是名字，可以换成 key：
type Obj = {
[key: string]: any;
};
但是项目里更推荐：
type Obj = {
[key: string]: unknown;
};
因为 any 会放弃类型检查，而 unknown 更安全。
const obj: Obj = {
name: "Tom",
age: 18,
};
const name = obj.name;
if (typeof name === "string") {
name.toUpperCase();
}
注意，一旦写了索引签名，明确属性也要兼容它：
type User = {
name: string;
age: number;
[key: string]: string | number;
};
5. in 的三种用法
5.1 判断属性是否存在
const user = {
name: "Tom",
age: 18,
};
console.log("name" in user); // true
console.log("email" in user); // false
5.2 联合类型收窄
type Cat = {
meow: () => void;
};
type Dog = {
bark: () => void;
};
function speak(animal: Cat | Dog) {
if ("meow" in animal) {
animal.meow();
} else {
animal.bark();
}
}
"meow" in animal 会让 TS 知道当前分支里 animal 是 Cat。
5.3 映射类型中遍历 key
type MyPartial<T> = {
[K in keyof T]?: T[K];
};
这里的 in 表示遍历 keyof T 中的每一个 key。
6. extends：不只是继承
extends 是 TS 中非常重要的关键字。核心可以理解成：
A extends B
意思是：
A 必须满足 B。
6.1 interface 继承
interface Person {
name: string;
}
interface Student extends Person {
school: string;
}
Student 同时拥有 name 和 school。
const s: Student = {
name: "Tom",
school: "No.1 School",
};
6.2 class 继承
class Animal {
move() {
console.log("move");
}
}
class Dog extends Animal {
bark() {
console.log("bark");
}
}
6.3 泛型约束
function printName<T extends { name: string }>(obj: T) {
console.log(obj.name);
}
意思是：
T 必须至少有 name: string。
printName({ name: "Tom", age: 18 }); // OK
printName({ age: 18 }); // 报错
你也可以写得更具体：
function handle<T extends { id: string; name: string }>(item: T): T {
return item;
}
这表示 T 至少要有 id 和 name：
const result = handle({
id: "001",
name: "Tom",
age: 18,
});
result.age; // OK
泛型约束的价值是：
既限制结构，又保留传入对象的完整类型。
6.4 条件类型
type IsString<T> = T extends string ? true : false;
使用：
type A = IsString<string>; // true
type B = IsString<number>; // false
这里的 extends 更准确地说是：
T 是否可以赋值给 string。
例如：
type A = "hello" extends string ? true : false;
// true
type B = string extends "hello" ? true : false;
// false
7. T extends object
function fn<T extends object>(value: T) {
return value;
}
T extends object 表示 T 必须是非原始类型。
可以：
fn({});
fn([]);
fn(() => {});
fn(new Date());
不可以：
fn("hello");
fn(123);
fn(true);
注意：数组和函数也属于 object。
如果你想表达普通键值对象，可以考虑：
Record<string, unknown>
但它和普通对象也不是完全等价，实际项目里要看具体场景。
8. object 和 Object 的区别
8.1 object
object 表示非原始类型。
let a: object;
a = {};
a = [];
a = () => {};
a = "hello"; // 报错
a = 123; // 报错
8.2 Object
Object 范围更宽，几乎表示所有非 null、非 undefined 的值。
let b: Object;
b = {};
b = [];
b = "hello";
b = 123;
b = true;
所以真实项目里不建议用大写 Object 表示普通对象。
更推荐：
unknown // 任意类型，安全
object // 非原始类型
Record<string, unknown> // 普通键值对象
9. 不用 any / unknown，如何表示所有 JS 值？
可以用联合类型：
type Primitive =
| string
| number
| boolean
| bigint
| symbol
| null
| undefined;
type AnyValue = Primitive | object;
因为 object 包含普通对象、数组、函数、Date、Map、Set 等非原始值。
如果你要表示 JSON 值，可以这样写：
type JsonValue =
| string
| number
| boolean
| null
| JsonValue[]
| { [key: string]: JsonValue };
JSON 不包含：
undefined
function
symbol
bigint
Date
Map
Set
10. 类型守卫：value is Xxx
类型守卫用于告诉 TS：
如果这个函数返回 true，那么参数就是某个类型。
function isPlainObject(value: unknown): value is Record<string, unknown> {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
使用：
function handle(value: unknown) {
if (isPlainObject(value)) {
value.name; // OK，类型是 unknown
}
}
属性值仍然是 unknown，所以要继续判断：
function handle(value: unknown) {
if (isPlainObject(value) && typeof value.name === "string") {
value.name.toUpperCase();
}
}
类型守卫不必须和 unknown 配合，也可以用于联合类型：
function isString(value: string | number): value is string {
return typeof value === "string";
}
11. 联合类型和交叉类型
11.1 联合类型 |
联合类型表示“或”。
type ID = string | number;
使用时需要收窄：
function printId(id: string | number) {
if (typeof id === "string") {
id.toUpperCase();
} else {
id.toFixed(2);
}
}
适合表达多种可能：
type Status = "loading" | "success" | "error";
11.2 交叉类型 &
交叉类型表示“且”。
type User = { name: string } & { age: number };
const user: User = {
name: "Tom",
age: 18,
};
交叉类型常用于合并对象结构：
type Base = {
id: string;
createdAt: string;
};
type User = Base & {
name: string;
};
注意基础类型交叉通常会得到 never：
type A = string & number;
// never
对象属性冲突也会导致不可能类型：
type A = { id: string } & { id: number };
// id: never
12. 函数重载
函数重载用于表达：
同一个函数，不同参数类型或参数数量，对应不同返回类型。
function fn(x: string): string;
function fn(x: number): number;
function fn(x: string | number): string | number {
return x;
}
前两行是重载签名，最后一行是实现签名。
调用时：
const a = fn("hello"); // string
const b = fn(123); // number
参数数量不同也可以重载：
function makeDate(timestamp: number): Date;
function makeDate(year: number, month: number, day: number): Date;
function makeDate(
yearOrTimestamp: number,
month?: number,
day?: number
): Date {
if (month !== undefined && day !== undefined) {
return new Date(yearOrTimestamp, month, day);
}
return new Date(yearOrTimestamp);
}
不允许两个参数调用：
makeDate(2026, 6); // 报错
如果返回值不随参数类型变化，优先用联合类型。
如果输入和输出保持同一种类型关系，优先用泛型。
13. 泛型
泛型可以理解成：
把类型当成参数传进去。
function identity<T>(value: T): T {
return value;
}
调用：
const a = identity("hello"); // string
const b = identity(123); // number
泛型的价值是：
既能复用逻辑，又能保留具体类型。
13.1 数组例子
function first<T>(arr: T[]): T | undefined {
return arr[0];
}
const a = first([1, 2, 3]); // number | undefined
const b = first(["a", "b"]); // string | undefined
13.2 多个泛型参数
function pair<T, U>(a: T, b: U): [T, U] {
return [a, b];
}
const result = pair("age", 18);
// [string, number]
13.3 泛型接口
type ApiResponse<T> = {
code: number;
message: string;
data: T;
};
使用：
type User = {
id: string;
name: string;
};
const res: ApiResponse<User> = {
code: 0,
message: "ok",
data: {
id: "001",
name: "Tom",
},
};
13.4 泛型默认值
type ApiResponse<T = unknown> = {
code: number;
data: T;
};
14. 泛型和 keyof
这个模板非常重要：
function getValue<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
使用：
const user = {
id: 1,
name: "Tom",
};
const id = getValue(user, "id"); // number
const name = getValue(user, "name"); // string
getValue(user, "age"); // 报错
这里同时用到了：
T
K extends keyof T
T[K]
它表达的是：
key 必须是 obj 的 key，返回值类型就是这个 key 对应的 value 类型。
15. infer
infer 用于条件类型中，作用是：
从一个类型结构中提取某一部分类型。
15.1 提取数组元素类型
type Item<T> = T extends Array<infer U> ? U : never;
使用：
type A = Item<string[]>; // string
type B = Item<number[]>; // number
15.2 提取 Promise 结果
type UnwrapPromise<T> = T extends Promise<infer R> ? R : T;
type A = UnwrapPromise<Promise<string>>;
// string
递归拆 Promise：
type DeepUnwrapPromise<T> = T extends Promise<infer R>
? DeepUnwrapPromise<R>
: T;
15.3 提取函数返回值
type MyReturnType<T> =
T extends (...args: any[]) => infer R ? R : never;
使用：
function getUser() {
return {
id: 1,
name: "Tom",
};
}
type User = MyReturnType<typeof getUser>;
// { id: number; name: string }
15.4 提取函数参数
type MyParameters<T> =
T extends (...args: infer P) => any ? P : never;
function createUser(id: string, age: number) {}
type Params = MyParameters<typeof createUser>;
// [id: string, age: number]
15.5 提取对象字段
type GetData<T> = T extends { data: infer D } ? D : never;
type Response = {
code: number;
data: {
id: string;
name: string;
};
};
type Data = GetData<Response>;
// { id: string; name: string }
16. TS 里的常用工具类型：源码实现 + 使用场景
TypeScript 内置了很多工具类型，它们本质上都是基于这些能力组合出来的：
- 泛型
keyof- 映射类型
[K in keyof T]
- 条件类型
T extends U ? X : Y
infer- 联合类型分发
下面逐个看常用工具类型。
16.1 Partial<T>
Partial<T> 会把对象类型的所有属性变成可选。
简化源码：
type MyPartial<T> = {
[K in keyof T]?: T[K];
};
使用示例：
type User = {
id: string;
name: string;
age: number;
};
type PartialUser = Partial<User>;
等价于：
type PartialUser = {
id?: string;
name?: string;
age?: number;
};
使用场景：更新部分字段。
function updateUser(id: string, patch: Partial<User>) {
// 只更新传入的字段
}
updateUser("001", {
name: "Jerry",
});
16.2 Required<T>
Required<T> 会把对象类型的所有属性变成必选。
简化源码：
type MyRequired<T> = {
[K in keyof T]-?: T[K];
};
这里的 -? 表示移除可选标记。
使用示例：
type User = {
id?: string;
name?: string;
};
type RequiredUser = Required<User>;
等价于：
type RequiredUser = {
id: string;
name: string;
};
使用场景：配置合并后，内部使用完整配置。
type Config = {
host?: string;
port?: number;
};
const defaultConfig: Required<Config> = {
host: "localhost",
port: 3000,
};
function createServer(config: Config) {
const finalConfig: Required<Config> = {
...defaultConfig,
...config,
};
finalConfig.host;
finalConfig.port;
}
16.3 Readonly<T>
Readonly<T> 会把对象属性变成只读。
简化源码：
type MyReadonly<T> = {
readonly [K in keyof T]: T[K];
};
使用示例：
type User = {
id: string;
name: string;
};
type ReadonlyUser = Readonly<User>;
等价于：
type ReadonlyUser = {
readonly id: string;
readonly name: string;
};
使用场景：防止函数内部修改传入对象。
function printUser(user: Readonly<User>) {
console.log(user.name);
user.name = "Jerry"; // 报错
}
注意：Readonly<T> 默认是浅只读。
type User = {
profile: {
age: number;
};
};
const user: Readonly<User> = {
profile: {
age: 18,
},
};
user.profile.age = 20; // 可以，因为 profile 内部不是 readonly
16.4 Pick<T, K>
Pick<T, K> 从对象类型中挑选部分属性。
简化源码：
type MyPick<T, K extends keyof T> = {
[P in K]: T[P];
};
使用示例：
type User = {
id: string;
name: string;
age: number;
password: string;
};
type UserBaseInfo = Pick<User, "id" | "name">;
等价于：
type UserBaseInfo = {
id: string;
name: string;
};
使用场景：接口返回、组件 props、表格字段。
type UserCardProps = Pick<User, "id" | "name">;
function renderUserCard(user: UserCardProps) {
return `${user.id} - ${user.name}`;
}
16.5 Omit<T, K>
Omit<T, K> 从对象类型中排除部分属性。
简化源码：
type MyOmit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
拆开看：
Exclude<keyof T, K>
先从所有 key 里排除 K，再用 Pick 取剩下的字段。
使用示例：
type User = {
id: string;
name: string;
password: string;
};
type PublicUser = Omit<User, "password">;
等价于：
type PublicUser = {
id: string;
name: string;
};
使用场景：隐藏敏感字段。
function toPublicUser(user: User): Omit<User, "password"> {
const { password, ...rest } = user;
return rest;
}
也常用于创建参数：
type CreateUserDto = Omit<User, "id">;
16.6 Record<K, T>
Record<K, T> 用来创建一个 key/value 对象类型。
简化源码：
type MyRecord<K extends keyof any, T> = {
[P in K]: T;
};
keyof any 等价于：
string | number | symbol
使用示例：
type Role = "admin" | "user" | "guest";
type RoleMap = Record<Role, string>;
等价于：
type RoleMap = {
admin: string;
user: string;
guest: string;
};
使用场景：枚举映射、状态映射、字典对象。
type Status = "pending" | "success" | "error";
const statusText: Record<Status, string> = {
pending: "处理中",
success: "成功",
error: "失败",
};
这样如果少写一个 key，TS 会报错：
const statusText: Record<Status, string> = {
pending: "处理中",
success: "成功",
// error 缺失，报错
};
16.7 Exclude<T, U>
Exclude<T, U> 从联合类型 T 中排除可以赋值给 U 的类型。
简化源码：
type MyExclude<T, U> = T extends U ? never : T;
使用示例：
type Status = "pending" | "success" | "error";
type NonErrorStatus = Exclude<Status, "error">;
结果：
type NonErrorStatus = "pending" | "success";
使用场景：从联合类型里排除某些值。
type EventName = "click" | "hover" | "focus";
type MouseEventName = Exclude<EventName, "focus">;
// "click" | "hover"
理解重点：
type MyExclude<T, U> = T extends U ? never : T;
当 T 是联合类型时，条件类型会自动分发：
Exclude<"a" | "b" | "c", "a">
相当于：
("a" extends "a" ? never : "a")
| ("b" extends "a" ? never : "b")
| ("c" extends "a" ? never : "c")
结果：
"b" | "c"
16.8 Extract<T, U>
Extract<T, U> 从联合类型 T 中提取可以赋值给 U 的类型。
简化源码：
type MyExtract<T, U> = T extends U ? T : never;
使用示例：
type Status = "pending" | "success" | "error";
type SuccessStatus = Extract<Status, "success" | "done">;
结果：
type SuccessStatus = "success";
使用场景：从联合类型中取交集。
type FrontendEvent = "click" | "hover" | "focus";
type SupportedEvent = "click" | "focus";
type AvailableEvent = Extract<FrontendEvent, SupportedEvent>;
// "click" | "focus"
16.9 NonNullable<T>
NonNullable<T> 从类型中排除 null 和 undefined。
简化源码：
type MyNonNullable<T> = T extends null | undefined ? never : T;
使用示例：
type Value = string | number | null | undefined;
type SafeValue = NonNullable<Value>;
结果：
type SafeValue = string | number;
使用场景：处理已经判空后的类型。
function assertValue<T>(value: T): NonNullable<T> {
if (value === null || value === undefined) {
throw new Error("value is empty");
}
return value;
}
16.10 ReturnType<T>
ReturnType<T> 用来获取函数返回值类型。
简化源码：
type MyReturnType<T extends (...args: any[]) => any> =
T extends (...args: any[]) => infer R ? R : never;
使用示例：
function getUser() {
return {
id: "001",
name: "Tom",
};
}
type User = ReturnType<typeof getUser>;
结果：
type User = {
id: string;
name: string;
};
使用场景：复用函数返回值类型，避免重复声明。
function createState() {
return {
count: 0,
user: null as null | { id: string; name: string },
};
}
type State = ReturnType<typeof createState>;
16.11 Parameters<T>
Parameters<T> 用来获取函数参数类型，结果是一个元组。
简化源码：
type MyParameters<T extends (...args: any[]) => any> =
T extends (...args: infer P) => any ? P : never;
使用示例：
function createUser(id: string, age: number) {
return { id, age };
}
type CreateUserParams = Parameters<typeof createUser>;
结果：
type CreateUserParams = [id: string, age: number];
使用场景：封装函数、转发参数。
function createUser(id: string, age: number) {
return { id, age };
}
function wrapper(...args: Parameters<typeof createUser>) {
return createUser(...args);
}
16.12 ConstructorParameters<T>
ConstructorParameters<T> 用来获取构造函数参数类型。
简化源码：
type MyConstructorParameters<T extends abstract new (...args: any[]) => any> =
T extends abstract new (...args: infer P) => any ? P : never;
使用示例：
class User {
constructor(public id: string, public name: string) {}
}
type UserConstructorParams = ConstructorParameters<typeof User>;
结果：
type UserConstructorParams = [id: string, name: string];
使用场景：工厂函数。
function createInstance<T extends abstract new (...args: any[]) => any>(
Ctor: T,
...args: ConstructorParameters<T>
): InstanceType<T> {
return new Ctor(...args);
}
如果遇到 abstract new 不好理解，可以先记：
new (...args: any[]) => any
表示构造函数类型。
16.13 InstanceType<T>
InstanceType<T> 用来获取构造函数创建出来的实例类型。
简化源码：
type MyInstanceType<T extends abstract new (...args: any[]) => any> =
T extends abstract new (...args: any[]) => infer R ? R : never;
使用示例：
class User {
id = "001";
name = "Tom";
}
type UserInstance = InstanceType<typeof User>;
结果：
type UserInstance = User;
使用场景：根据 class 自动得到实例类型。
class Service {
request() {}
}
type ServiceInstance = InstanceType<typeof Service>;
const service: ServiceInstance = new Service();
16.14 Awaited<T>
Awaited<T> 用来获取 Promise 最终 resolve 出来的类型。
真实源码更复杂，这里写一个简化版本：
type MyAwaited<T> = T extends Promise<infer R>
? MyAwaited<R>
: T;
使用示例：
type A = Awaited<Promise<string>>;
// string
type B = Awaited<Promise<Promise<number>>>;
// number
使用场景：提取异步函数返回数据类型。
async function fetchUser() {
return {
id: "001",
name: "Tom",
};
}
type User = Awaited<ReturnType<typeof fetchUser>>;
拆开看：
ReturnType<typeof fetchUser>
得到：
Promise<{ id: string; name: string }>
再用：
Awaited<...>
得到：
{ id: string; name: string }
16.15 ReadonlyArray<T>
ReadonlyArray<T> 表示只读数组。
使用示例：
const nums: ReadonlyArray<number> = [1, 2, 3];
nums.push(4); // 报错
nums[0] = 10; // 报错
也可以写成：
const nums: readonly number[] = [1, 2, 3];
使用场景：函数不应该修改传入数组。
function sum(nums: readonly number[]) {
return nums.reduce((total, item) => total + item, 0);
}
16.16 ThisParameterType<T>
ThisParameterType<T> 用来提取函数里的 this 参数类型。
简化源码：
type MyThisParameterType<T> =
T extends (this: infer U, ...args: any[]) => any ? U : unknown;
使用示例：
function fn(this: { name: string }, age: number) {
console.log(this.name, age);
}
type ThisTypeOfFn = ThisParameterType<typeof fn>;
结果：
type ThisTypeOfFn = {
name: string;
};
使用场景：处理依赖 this 的老代码或库封装。
16.17 OmitThisParameter<T>
OmitThisParameter<T> 用来移除函数里的 this 参数。
function fn(this: { name: string }, age: number) {
console.log(this.name, age);
}
type FnWithoutThis = OmitThisParameter<typeof fn>;
结果类似：
type FnWithoutThis = (age: number) => void;
使用场景：把依赖 this 的函数 bind 之后再使用。
const bound = fn.bind({ name: "Tom" });
const run: OmitThisParameter<typeof fn> = bound;
16.18 工具类型组合使用
工具类型真正强大的地方在于组合。
示例 1：提取异步函数返回数据。
async function getUser() {
return {
id: "001",
name: "Tom",
};
}
type User = Awaited<ReturnType<typeof getUser>>;
示例 2：创建接口入参类型。
type User = {
id: string;
name: string;
password: string;
createdAt: string;
};
type CreateUserDto = Omit<User, "id" | "createdAt">;
结果：
type CreateUserDto = {
name: string;
password: string;
};
示例 3：更新接口入参。
type UpdateUserDto = Partial<Omit<User, "id" | "createdAt">>;
结果：
type UpdateUserDto = {
name?: string;
password?: string;
};
示例 4：状态映射。
type Status = "pending" | "success" | "error";
const statusText: Record<Status, string> = {
pending: "处理中",
success: "成功",
error: "失败",
};
示例 5：从联合类型中排除某些状态。
type Status = "pending" | "success" | "error" | "cancelled";
type ActiveStatus = Exclude<Status, "cancelled">;
16.19 小结
常用工具类型可以按用途分类记忆。
对象属性处理：
Partial<T>
Required<T>
Readonly<T>
Pick<T, K>
Omit<T, K>
Record<K, T>
联合类型处理：
Exclude<T, U>
Extract<T, U>
NonNullable<T>
函数类型处理：
ReturnType<T>
Parameters<T>
ThisParameterType<T>
OmitThisParameter<T>
构造函数处理：
ConstructorParameters<T>
InstanceType<T>
异步类型处理：
Awaited<T>
它们背后的核心能力其实就几个：
keyof
in
extends
infer
映射类型
条件类型
联合类型分发
掌握这些底层能力后，工具类型就不是黑盒了。
17. 实战建议
写 TS 时可以记住这些习惯：
- 不确定类型时，优先用
unknown，少用 any。
- 对外部数据，比如接口返回值，不要盲信类型。
- 描述动态对象时，优先考虑
[key: string]: unknown。
- 对普通对象可以用
Record<string, unknown>，但要理解它不是所有对象。
- 表达多种状态时，用联合类型。
- 表达对象合并时，用交叉类型。
- 参数和返回值有类型关系时，用泛型。
- 不同参数组合对应不同返回类型时，用函数重载。
- 从复杂类型里提取子类型时，用
infer。
-
extends 不只表示继承，更常用于泛型约束和条件类型判断。
18. 总结
这篇文章里，我们围绕 TS 类型系统梳理了这些重点：
[key: string]: unknown
用于描述动态属性。
"name" in obj
用于属性判断和类型收窄。
T extends SomeType
用于泛型约束。
T extends U ? X : Y
用于条件类型判断。
value is SomeType
用于自定义类型守卫。
A | B
表示联合类型，满足其中一种。
A & B
表示交叉类型，同时满足多种。
function identity<T>(value: T): T
表示泛型函数。
T extends Array<infer U> ? U : never
表示从数组中提取元素类型。
TypeScript 的难点不在于语法多，而在于要理解这些语法背后的共同目标：
用类型系统描述真实业务里的数据关系，让错误尽量在编译期暴露出来。
当你能熟练使用 extends、keyof、泛型、类型守卫、infer 这些工具时，就已经进入 TS 类型系统的核心区域了。
登录
