跳到主要内容

type高级类型和函数

Partial：Partial 是 TypeScript 内置函数，可以将一个类型的所有属性变为可选。这可以在需要允许某些属性为空的情况下使用。例如​

// 定义一个接口
interface Person {
  name: string;
  age: number;
  address: string;
}

// 将 Person 对象的所有属性变为可选
type PartialPerson = Partial<Person>;

// 可以使用不完整的对象来初始化 PartialPerson
const person: PartialPerson = {}; // OK
const person2: PartialPerson = { name: "Tom" }; // OK

Required：与 Partial 相反，Required 可以将一个具有可选属性的类型变为必需属性的类型。例如​

// 将可选属性的 Person 类型变为必须属性的类型
type RequiredPerson = Required<PartialPerson>;

// 必须使用所有属性来初始化 RequiredPerson
const person: RequiredPerson = { name: "Tom", age: 20, address: "New York" }; // OK

Readonly：将所有属性变为只读属性的类型。例如​

// 将 Person 对象的所有属性变为只读属性
type ReadonlyPerson = Readonly<Person>;

// 可以读取 ReadonlyPerson 的属性，但不能修改它们
const person: ReadonlyPerson = { name: "Tom", age: 20, address: "New York" };
console.log(person.name); // OK
person.age = 30; // Error: Cannot assign to 'age' because it is a read-only property.

Record：用于创建一个类型，该类型由指定的一组属性名和属性值类型组成。例如​

// 使用 Record 创建一个对象，其中属性名为字符串，属性值为数字
type StringToNumberRecord = Record<string, number>;

// 字符串名称的属性都必须为 Number 类型
const record: StringToNumberRecord = { "one": 1, "two": 2, "three": 3 };

Pick：Pick 是一个类似于 Partial 的内置类型函数。它可以选择一个类型的一些属性，并返回包含这些属性的新类型。例如​

// 从 Person 中选择一个 name 属性
type PersonName = Pick<Person, "name">;

// 只需要使用包含 name 属性的对象类型进行初始化
const person: PersonName = { name: "Tom" };

Omit：Omit 类似于 Pick，但允许从一个类型中排除一些属性。例如​

// 从 Person 中排除 name 属性
type PersonWithoutName = Omit<Person, "name">;

// 只需要使用不包含 name 属性的对象类型进行初始化
const person: PersonWithoutName = { age: 20, address: "New York" };

Exclude：Exclude 是 TypeScript 内置类型函数，用于从联合类型中排除一些类型。例如​

// 从数字类型中排除 1 和 2
type NumbersWithoutOneAndTwo = Exclude<number, 1 | 2>;

// 只能使用不包含 1 和 2 的数字类型进行初始化
const number: NumbersWithoutOneAndTwo = 3;

Extract：与 Exclude 相反，Extract 是 TypeScript 内置类型函数，用于从联合类型中提取某些类型。例如​

// 从数字类型中提取 1 和 2
type NumbersOneAndTwoOnly = Extract<number, 1 | 2>;

// 只能使用数字 1 或 2 进行初始化
const number: NumbersOneAndTwoOnly = 2;

NonNullable：NonNullable 是 TypeScript 内置类型函数，用于创建一个类型，该类型去除了 null 和 undefined 类型。例如​

// 创建一个只包含非空 Person 对象的数组
type NonNullablePersons = NonNullable<Person[]>;

// 只能使用不包含空值的 Person 对象数组进行初始化
const persons: NonNullablePersons = [ { name: "Tom", age: 20, address: "New York" }, { name: "John", age: 25, address: "Los Angeles" } ];

ReturnType：ReturnType 是 TypeScript 内置类型函数，用于从函数类型中提取返回值类型。例如​

// 获取函数返回值类型
function add(a: number, b: number): number {
  return a + b;
}
type AddReturnType = ReturnType<typeof add>;

// 只能使用数字类型初始化
const result: AddReturnType = 5;

Parameters：Parameters 是 TypeScript 内置类型函数，用于从函数类型中提取参数类型。例如​

// 获取函数参数类型
function concat(a: string, b: string, c: string): string {
  return a + b + c;
}
type ConcatParamsType = Parameters<typeof concat>;

// 只能使用三个字符串类型参数进行初始化
const result: ConcatParamsType = [ "hello", "world", "!" ];

Keyof：Keyof 是 TypeScript 内置类型函数，用于获取对象属性名称类型。例如​

// 获取对象属性名称
interface Person {
  name: string;
  age: number;
  address: string;
}
type PersonKeysType = keyof Person;

// 只能使用 Person 对象的属性名称进行初始化
const key: PersonKeysType = "name";

ThisType：ThisType 是 TypeScript 内置类型，用于在链式调用中指定函数的 this 类型。例如​

// 指定函数的 this 类型
interface Person {
  name: string;
  sayHello: (this: Person) => void;
}
const person: Person = {
  name: "Tom",
  sayHello() {
    console.log(`Hello, ${this.name}!`);
  }
};
person.sayHello(); // 输出：Hello, Tom!

Mapped types：Mapped types 可以用于从现有类型创建新类型。例如，可以使用 mapped type 编写一个类型，该类型使所有属性都变为可选，默认为 undefined。例如​

// 使用 mapped types 创建一个类型，将所有属性变为可选，默认为 undefined
type Optional<T> = { [P in keyof T]?: T[P] | undefined };
interface Person {
  name: string;
  age?: number;
  address?: string;
}
type OptionalPerson = Optional<Person>;

// 可以使用不完整的对象进行初始化
const person: OptionalPerson = { name: "Tom" };