TypeScript 工具类型

这些工具类型是 TypeScript 提供的强大功能，用于操作和转换类型。下面是每个工具类型的简要说明和示例：

1、Record

let value: Record<string, any> = { name: "", age: 0, desc: [] };
let value2: { [key: string]: any } = { name: "", age: 0, desc: [] };

2、Partial<T>: 将类型 T 的所有属性设置为可选。

  interface Person {
    name: string;
    age: number;
  }

  type PartialPerson = Partial<Person>; // { name?: string; age?: number; }

  let value: PartialPerson = {};
  let value2: PartialPerson = { name: "" };
  let value3: PartialPerson = { age: 0 };

3、 Required<T>: 将类型 T 的所有属性设置为必选。

interface PartialPerson {
    name?: string;
    age?: number;
}

type RequiredPerson = Required<PartialPerson>; // { name: string; age: number; }

let value: RequiredPerson = { name: "", age: 0 };

4、 Exclude<T, U>: 从类型 T 中排除 U 的类型。

  type T = string | number | boolean;
  type U = string | number;
  type Excluded = Exclude<T, U>; // 结果为 boolean

  let value: Excluded = false;

5、Omit<T, K>: 从类型 T 中移除属性 K。

  interface Person {
    name: string;
    age: number;
    address: string;
  }

  type WithoutAddress = Omit<Person, 'address'>; // 结果为 { name: string; age: number; }

  let value: WithoutAddress = { name: "", age: 0 };

6、Readonly<T>: 将类型 T 的所有属性设置为只读。

  interface Person {
    readonly name: string;
    readonly age: number;
  }

  type ReadonlyPerson = Readonly<Person>;

  let value: ReadonlyPerson = { name: '', age: 0 };

7、 Pick<T, K>: 从类型 T 中选取指定属性 K 构造新类型。

interface Person {
    name: string;
    age: number;
    address: string;
}

type NameAndAge = Pick<Person, 'name' | 'age'>; // { name: string; age: number; }

let value: NameAndAge = { name: '', age: 0 };

8、NonNullable<T>: 从类型 T 中排除 null 和 undefined。

type NullableString = string | null | undefined;
type NonNullableString = NonNullable<NullableString>; // 结果为 string

let value: NonNullableString = '';

9、ReturnType<T>: 获取函数类型 T 的返回值类型。

type Func = () => string;
type Result = ReturnType<Func>; // 结果为 string
  
let value: Result = '';

 10、Parameters<T>: 获取函数类型 T 的参数类型组成的元组。

type Func = (x: number, y: string) => boolean;
type Args = Parameters<Func>; // 结果为 [number, string]

let value: Args = [0, ''];

 11、Overwrite<T, U>: 使用 U 中的属性覆盖 T 中的对应属性。

type T = { a: number; b: string };
type U = { b: boolean; c: string };
type Overwrite<T, U> = Omit<T, keyof U> & U;
type OverwriteType = Overwrite<T, U>; // 结果为 { a: number; b: boolean; c: string; }

let value: OverwriteType = { a: 0, b: true, c: '' };

12、Intersection<T, U>: 返回 T 和 U 的交集类型。

type T = { a: number; b: string };
type U = { b: boolean; c: string };
type Intersection<T, U> = Omit<T, keyof Omit<T, keyof U>>;
type Intersected = Intersection<T, U>; // 结果为 { b: string; }

let value: Intersected = { b: '' };