实用工具类型
1. 基础类型转换工具
Partial<Type>
将类型的所有属性变为可选（?）。
type User = {
name: string;
age: number;
};
type PartialUser = Partial<User>;
// 等价于: { name?: string; age?: number }
Required<Type>
将类型的所有可选属性变为必选。
type Options = {
timeout?: number;
retry?: boolean;
};
type RequiredOptions = Required<Options>;
// 等价于: { timeout: number; retry: boolean }
Readonly<Type>
将类型的所有属性变为只读（readonly）。
type Point = {
x: number;
y: number;
};
type ReadonlyPoint = Readonly<Point>;
// 等价于: { readonly x: number; readonly y: number }
2. 对象属性操作工具
Record<Keys, Type>
创建一个包含指定键和值类型的对象类型。
type Weekday = 'Mon' | 'Tue' | 'Wed' | 'Thu' | 'Fri';
type DayTemp = Record<Weekday, number>;
// 等价于: { Mon: number; Tue: number; ...; Fri: number }
Pick<Type, Keys>
从类型中选择指定的属性。
type User = {
id: number;
name: string;
age: number;
};
type UserName = Pick<User, 'id' | 'name'>;
// 等价于: { id: number; name: string }
Omit<Type, Keys>
从类型中移除指定的属性。
type User = {
id: number;
name: string;
age: number;
email: string;
};
type UserWithoutEmail = Omit<User, 'email' | 'age'>;
// 等价于: { id: number; name: string }
3. 联合类型操作工具
Exclude<UnionType, ExcludedMembers>
从联合类型中排除某些成员。
type Numbers = 1 | 2 | 3 | 4 | 5;
type EvenNumbers = Exclude<Numbers, 1 | 3 | 5>;
// 结果: 2 | 4
Extract<Type, Union>
从类型中提取符合联合类型的成员。
type Values = string | number | boolean | null;
type PrimitiveValues = Extract<Values, string | number | boolean>;
// 结果: string | number | boolean
NonNullable<Type>
从类型中排除 null 和 undefined。
type Input = string | number | null | undefined;
type CleanedInput = NonNullable<Input>;
// 结果: string | number
4. 函数类型操作工具
Parameters<Type>
获取函数的参数类型组成的元组。
type Func = (a: string, b: number) => void;
type Params = Parameters<Func>;
// 结果: [string, number]
ConstructorParameters<Type>
获取类构造函数的参数类型组成的元组。
class Person {
constructor(name: string, age: number) {}
}
type PersonParams = ConstructorParameters<typeof Person>;
// 结果: [string, number]
ReturnType<Type>
获取函数的返回值类型。
type GetUser = () => { id: number; name: string };
type UserType = ReturnType<GetUser>;
// 结果: { id: number; name: string }
InstanceType<Type>
获取类的实例类型。
class Point {
x: number;
y: number;
}
type PointInstance = InstanceType<typeof Point>;
// 结果: Point
5. 高级类型工具
Awaited<Type>
递归展开 Promise 类型，获取最终的 resolved 值类型。
type A = Awaited<Promise<string>>;
// 结果: string
type B = Awaited<Promise<Promise<number>>>;
// 结果: number
NoInfer<Type>
阻止类型推断，保留泛型参数的精确类型。
type NoInfer<T> = [T][T extends any ? 0 : never];
function identity<T>(arg: T): T {
return arg;
}
// 不使用 NoInfer，类型会被推断为 number
const result1 = identity(123);
// 使用 NoInfer，类型保持为字面量 123
const result2 = identity<NoInfer<123>>(123);
6. 上下文类型工具
ThisParameterType<Type>
获取函数的 this 参数类型。
type GetThis = (this: { name: string }) => void;
type ThisType = ThisParameterType<GetThis>;
// 结果: { name: string }
OmitThisParameter<Type>
移除函数类型中的 this 参数。
type Func = (this: Window, x: number) => void;
type NewFunc = OmitThisParameter<Func>;
// 结果: (x: number) => void
ThisType<Type>
在对象字面量中指定 this 的类型（需配合 --noImplicitThis 选项）。
type ObjectDescriptor<D, M> = {
data?: D;
methods?: M & ThisType<D & M>; // 方法中的 this 类型为 D & M
};
const obj: ObjectDescriptor<{ x: number }, { printX(): void }> = {
data: { x: 10 },
methods: {
printX() {
console.log(this.x); // this 类型为 { x: number } & { printX(): void }
}
}
};
7. 字符串操作工具
Uppercase<StringType>
将字符串类型转换为大写。
type Greeting = "hello";
type ShoutGreeting = Uppercase<Greeting>;
// 结果: "HELLO"
Lowercase<StringType>
将字符串类型转换为小写。
type Greeting = "HELLO";
type QuietGreeting = Lowercase<Greeting>;
// 结果: "hello"
Capitalize<StringType>
将字符串的首字母转换为大写。
type Name = "john";
type CapitalizedName = Capitalize<Name>;
// 结果: "John"
Uncapitalize<StringType>
将字符串的首字母转换为小写。
type ID = "Id";
type UncapitalizedID = Uncapitalize<ID>;
// 结果: "id"
总结
这些工具类型是 TypeScript 类型系统的强大辅助，可帮助你：
- 简化类型定义：如
Partial、Required、Readonly - 操作对象结构：如
Pick、Omit、Record - 处理联合类型：如
Exclude、Extract、NonNullable - 解析函数和类类型：如
Parameters、ReturnType、InstanceType - 处理异步类型：如
Awaited - 操作字符串类型：如
Uppercase、Capitalize