TS内置类型

Partial （部分的）

// 会将传入的类型所有值变为可选的
type Partial<T> = {
    [P in keyof T]?: T[P];
};

interface Test {
  num1: number;
  num2: number;
}

/* 
  Partial<Test>的类型为
  {
    num1?: number;
    num2?: number;
  }
 */

Required （必须的）

// 会将传入的类型所有值变为必选的
type Required<T> = {
    [P in keyof T]-?: T[P];
};

interface Test {
  num1?: number;
  num2?: number;
}

/* 
  Required<Test>的类型为
  {
    num1: number;
    num2: number;
  }
 */

Readonly （只读的）

// 会将所有属性变为只读的
type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

Pick （选择）

// 会从T类型中选择一个属性形成一个新的类型
type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};
const res: Pick<Test, 'num1'> = {
  num1: 111,
};

Record (记录)

//用于构建key类型一样，value类型一样的类型
type Record<K extends keyof any, T> = {
    [P in K]: T;
};

《key值类型，value类型》
const student1: Record<number, string> = {
  1: '张三',
  2: 'sss',
};

Exclude（排除）

//针对联合类型（interface这种没用），用人话说，排除相同的，留下不同的
type Exclude<T, U> = T extends U ? never : T;
//例子： student1类型为 'class' | 'school'
export type PersonAttr = 'name' | 'age'

export type StudentAttr = 'name' | 'age' | 'class' | 'school'

const student1: Exclude<StudentAttr, PersonAttr>

Extract（取出）

//与Exclude相反，针对联合类型，排除不同的的，取出相同的
type Extract<T, U> = T extends U ? T : never;
//例子： student1类型为 "name" | "age"
export type PersonAttr = 'name' | 'age'

export type StudentAttr = 'name' | 'age' | 'class' | 'school'

const student1: Exclude<StudentAttr, PersonAttr>

Omit（省略）

//传入一个类型，和这个类型的几个属性，把传入的属性省略掉，组成一个新类型
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
/* 
例子 student1类型为 {
  class: string;
  school: string
}
 */

interface Student {
  name: string;
  age: number;
  class: string;
  school: string;
}

type PersonAttr = 'name' | 'age';

type StudentAttr = 'name' | 'age' | 'class' | 'school';

const student1: Omit<Student, PersonAttr> = {
  class: '',
  school: '',
};

NonNullable（不能为null）

type NonNullable<T> = T extends null | undefined ? never : T;

Parameters（参数）

//获取传入函数的参数组成的类型
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
//例子student1的类型由StudentFunc的入参类型决定【name:string,age:number】

export interface Student {
  name: string;
  age: number;
}

export interface StudentFunc {
  (name: string, age: number): Student;
}

const student1: Parameters<StudentFunc> = ['kkk', 1];

ConstructorParameters（构造参数）

//获取传入构造函数的参数组成的类型
type ConstructorParameters<T extends abstract new (...args: any) => any> = T 

//例子student1的类型由StudentConstructor的入参类型决定【name:string,age:number】
extends abstract new (...args: infer P) => any ? P : never;
export interface Student {
  name: string;
  age: number;
}

export interface StudentConstructor {
  new (name: string, age: number): Student
}

const student1: ConstructorParameters<StudentConstructor>=['kkk', 1];

ReturnType（返回类型）

//获取传入函数的返回类型
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
//例子 student1类型由StudentFunc函数的返回值类型确定
export interface Student {
  name: string;
  age: number;
}

export interface StudentFunc {
  (name: string, age: number): Student;
}

const student1: ReturnType<StudentFunc> = {
  name: '11',
  age: 11,
};

Uppercase（大写）

//会将联合类型变为大写
type Uppercase<S extends string> = intrinsic;
//例子 studentSex 类型为  'MALE' | 'FEMALE'
export type StudentSexType = 'male' | 'female'

const studentSex: Uppercase<StudentSexType> = 'MALE'

Lowercase（小写）

//会将联合类型变为小写
type Lowercase<S extends string> = intrinsic;
//例子 studentSex类型为 'male' | 'female'
export type StudentSexType = 'MALE' | 'FEMALE'

const studentSex: Lowercase<StudentSexType> = ''

Capitalize 首字母大写

Uncapitalize 首字母小写

这 4 种操作字符串字面量工具类型的实现都是使用 JavaScript 运行时的字符串操作函数计算出来的，
且不支持语言区域设置。以下代码是这 4 种字符串工具类型的实际实现。
function applyStringMapping(symbol: Symbol, str: string) {

  switch (intrinsicTypeKinds.get(symbol.escapedName as string)) {
    case IntrinsicTypeKind.Uppercase:
      return str.toUpperCase();

    case IntrinsicTypeKind.Lowercase:
      return str.toLowerCase();

    case IntrinsicTypeKind.Capitalize:
      return str.charAt(0).toUpperCase() + str.slice(1);

    case IntrinsicTypeKind.Uncapitalize:
      return str.charAt(0).toLowerCase() + str.slice(1);

  }

  return str;
}