Partial
Partial用于将给定类型的所有属性设置为可选。换句话说，Partial 可以创建一个新的类型，该类型具有与原始类型相同的属性，但是这些属性都是可选的。使用 Partial 可以很方便地定义一个对象，其中的属性可以选择性地进行赋值。

interface User {name: string;age: number;email: string;
}function updateUser(user: Partial<User>): void {// 更新用户信息// ...
}const user: User = {name: "John",age: 30,email: "john@example.com"
};updateUser({ name: "John Doe" }); // 仅更新名称
updateUser({ age: 31, email: "john.doe@example.com" }); // 仅更新年龄和邮箱

Required
Required 用于将给定类型的所有属性设置为必需的。换句话说，Required 可以创建一个新的类型，该类型具有与原始类型相同的属性，但是这些属性都是必需的，不能省略。

interface User {name?: string;age?: number;email?: string;
}function createUser(user: Required<User>): void {// 创建用户// ...
}createUser({ name: "John", age: 30, email: "john@example.com" }); // 完整的用户信息
createUser({ name: "John" }); // 缺少必需的属性，会报错

Readonly
Readonly用于将给定类型的所有属性设置为只读。换句话说，Readonly 可以创建一个新的类型，该类型具有与原始类型相同的属性，但是这些属性都是只读的，不能被修改。使用 Readonly 可以很方便地定义一个只读的对象，其中的属性不能被修改。这对于确保对象的不可变性和类型安全非常有用。

interface User {readonly name: string;readonly age: number;readonly email: string;
}function getUser(): Readonly<User> {return { name: "John", age: 30, email: "john@example.com" };
}const user: Readonly<User> = getUser();console.log(user.name); // John
user.name = "John Doe"; // 无法修改只读属性，会报错

Pick
Pick 用于从给定类型中选择指定的属性，并创建一个新的类型。换句话说，Pick 可以从一个对象类型中挑选出指定的属性，创建一个新的类型，该类型只包含指定的属性。使用 Pick 可以很方便地从一个复杂的类型中选择需要的部分，减少了不必要的冗余信息，提高了代码的可读性和灵活性。

interface User {name: string;age: number;email: string;address: string;
}type UserBasicInfo = Pick<User, "name" | "age">;const user: UserBasicInfo = {name: "John",age: 30,
};

Record
Record 用于创建一个具有指定属性类型的对象类型。Record 接受两个类型参数，第一个参数指定属性的名称，第二个参数指定属性的类型。
使用 Record 可以很方便地定义一个具有指定属性类型的对象类型，这对于创建字典、映射等数据结构非常有用。

type Fruit = "apple" | "banana" | "orange";
type Price = number;const fruitPrices: Record<Fruit, Price> = {apple: 1.5,banana: 0.5,orange: 0.8,
};console.log(fruitPrices.apple); // 1.5
console.log(fruitPrices.banana); // 0.5
console.log(fruitPrices.orange); // 0.8

Exclude
Exclude 用于从一个联合类型中排除指定的类型。
Exclude 接受两个类型参数，第一个参数是要排除的类型，第二个参数是要从中排除类型的联合类型。
下面是一个例子，演示了如何使用 Exclude 类型工具：

type Animal = "dog" | "cat" | "bird";
type ExcludeBird = Exclude<Animal, "bird">;
const myPets: ExcludeBird[] = ["dog", "cat"];

Extract
Extract 用于从一个联合类型中提取指定的类型。
Extract 接受两个类型参数，第一个参数是要提取的类型，第二个参数是要从中提取类型的联合类型。

type Animal = "dog" | "cat" | "bird";
type ExtractBird = Extract<Animal, "bird">;
const myBird: ExtractBird = "bird";

Omit
Omit 用于从一个对象类型中排除指定的属性。
Omit 接受两个类型参数，第一个参数是要从中排除属性的对象类型，第二个参数是要排除的属性的名称。

type Person = {name: string;age: number;gender: string;
};type OmitAge = Omit<Person, "age">;const personWithoutAge: OmitAge = {name: "John",gender: "male"
};

NonNullable
NonNullable 用于从一个类型中排除 null 和 undefined。
NonNullable 接受一个类型参数，该参数表示要排除 null 和 undefined 的类型。

type NullableString = string | null | undefined;
type NonNullableString = NonNullable<NullableString>;
const str: NonNullableString = "Hello";

Parameters
Parameters 是一个泛型工具类型，它用于获取函数类型 T 的参数类型。它接受一个函数类型作为参数，并返回一个元组类型，其中包含了函数的每个参数类型。

function greet(name: string, age: number): void {console.log(`Hello, ${name}! You are ${age} years old.`);
}

可以使用Parameters来获取greet函数的参数类型：

type GreetParams = Parameters<typeof greet>;
// GreetParams 的类型为 [string, number]

ConstructorParameters
ConstructorParameters 用于获取构造函数的参数类型。
ConstructorParameters 接受一个构造函数类型作为参数，并返回一个元组类型，该元组类型包含了构造函数的参数类型。

class Person {constructor(name: string, age: number) {// constructor implementation}
}
type PersonConstructorParams = ConstructorParameters<typeof Person>;
const params: PersonConstructorParams = ["John", 25];

ReturnType
ReturnType是一个泛型工具类型，它用于获取函数类型T的返回值类型。它接受一个函数类型作为参数，并返回该函数的返回值类型。

function add(a: number, b: number): number {return a + b;
}

可以使用ReturnType来获取add函数的返回值类型：

type AddResult = ReturnType<typeof add>;
// AddResult 的类型为 number

InstanceType
InstanceType 用于获取构造函数的实例类型。
InstanceType 接受一个构造函数类型作为参数，并返回该构造函数类型的实例类型。

class Person {name: string;age: number;constructor(name: string, age: number) {this.name = name;this.age = age;}sayHello() {console.log(`Hello, my name is ${this.name} and I'm ${this.age} years old.`);}
}type PersonInstance = InstanceType<typeof Person>;const person: PersonInstance = new Person("John", 25);
person.sayHello();

Uppercase
Uppercase 用于将字符串类型的字母转换为大写。
Uppercase 接受一个字符串类型作为参数，并返回该字符串类型的大写版本。

type UppercaseString = Uppercase<"hello">;
// UppercaseString 的类型为 "HELLO"const str: UppercaseString = "HELLO";

Lowercase
Lowercase 用于将字符串类型的字母转换为小写。
Lowercase 接受一个字符串类型作为参数，并返回该字符串类型的小写版本。

type LowercaseString = Lowercase<"HELLO">;
// LowercaseString 的类型为 "hello"const str: LowercaseString = "hello";

Capitalize
Capitalize 用于将字符串的第一个字符转换为大写。

type MyString = 'hello';
type CapitalizedString = Capitalize<MyString>;
// CapitalizedString 的类型为 'Hello'

Uncapitalize
Uncapitalize用于将字符串的第一个字符转换为小写。

type MyString = 'Hello';
type UncapitalizedString = Uncapitalize<MyString>;
// UncapitalizedString 的类型为 'hello'

https://www.zhihu.com/question/453332049/answer/3145262802