TypeScript内置类型一览（Record＜string,any＞等等）

/**
 * Make all properties in T optional
 */
type Partial = {
    [P in keyof T]?: T[P];
};
1
2
3
4
5
6

export interface Student {
  name: string;
  age: number;
}
1
2
3
4

const student1: Student = {}

const student2: Partial = {}

变量student1的类型是Student，Student默认所有的属性都是不能为空的，所有会报错，student2就不会

Required（必须的）

/**
1

• Make all properties in T required
  */
  type Required = {
  [P in keyof T]-?: T[P];
  };
  

  跟Partial的作用是相反的，是让传入类型中的所有属性变成都是必填的

  使用举例

  export interface Student {
  
  name?: string;
  
  age?: number;
  
  }
  1
  2
  3

const student1: Student = {}

const student2: Required = {}

变量student1的类型是Student，Student默认所有的属性都是可以为空的，所有不会报错，student2会报错

Readonly（只读的）

/**
1

• Make all properties in T readonly
  */
  type Readonly = {
  readonly [P in keyof T]: T[P];
  };
  

  作用是让传入类型中的所有属性变成都是只读的（不能修改属性）

  使用举例

  export interface Student {
  
  name: string;
  
  age: number;
  
  }
  1
  2
  3

const student1: Student = {
name: ‘张三’,
age: 20
}
student1.age = 21

const student2: Readonly = {
name: ‘李四’,
age: 20
}
student2.age = 21

给student1的属性age重新赋值不会报错，给student2的属性age重新赋值就会报错，因为student2所有的属性都是只读的

Pick（选择）

/**
1

• From T, pick a set of properties whose keys are in the union K
  */
  type Pick = {
  [P in K]: T[P];
  };
  

  作用是选择传入类型中的部分属性组成新类型

  使用举例

  export interface Student {
  
  name: string;
  
  age: number;
  
  }
  1
  2
  3

const student1: Student = {
name: ‘张三’,
age: 20
}

const student2: Pick = {
name: ‘李四’
}

const student3: Pick = {
name: ‘王五’,
age: 20
}

变量student1可以有所有属性name和age，变量student2就只能有属性name，变量student3加上属性age就会报错

Record（记录）

/**
1

• Construct a type with a set of properties K of type T
  /
  type Record = {
  [P in K]: T;
  };
  

  作用是构建一个类型，这个类型用来描述一个对象，这个对象的属性都具有相同的类型

  使用举例

  export const student1: Record = {
  
  name: ‘张三’,
  
  age: 20
  
  }
  
  1
  2
  3
  4

  Record应该是日常使用频率较高的内置类型了，主要用来描述对象，一般建议是不用Object来描述对象，而是用Record代替，Record几乎可以说是万金油了

  Exclude（排除）

  /*
  

• Exclude from T those types that are assignable to U
  */
  type Exclude = T extends U ? never : T;
  

  针对联合类型（interface这种没用），用人话说，排除相同的，留下不同的

  使用举例

  export type PersonAttr = ‘name’ | ‘age’
  

export type StudentAttr = ‘name’ | ‘age’ | ‘class’ | ‘school’

const student1: Exclude

student1就只能被赋值为’class’ 或者’school’

Extract（取出）

/**
1

• Extract from T those types that are assignable to U
  */
  type Extract = T extends U ? T : never;
  

  与Exclude相反，针对联合类型，排除不同的的，取出相同的

  使用举例

  export type PersonAttr = ‘name’ | ‘age’
  

export type StudentAttr = ‘name’ | ‘age’ | ‘class’ | ‘school’

const student1: Extract

student1就只能被赋值为’name’或者’age’

Omit（省略）

/**
1

• Construct a type with the properties of T except for those in type K.
  */
  type Omit = Pick>;
  

  传入一个类型，和这个类型的几个属性，把传入的属性省略掉，组成一个新类型

  使用举例

  export interface Student {
  
  name: string;
  
  age: number;
  
  class: string;
  
  school: string;
  
  }
  1
  2
  3
  4
  5

export type PersonAttr = ‘name’ | ‘age’

export type StudentAttr = ‘name’ | ‘age’ | ‘class’ | ‘school’

const student1: Omit = {}

student1报错，提示没有属性’name’、‘age’

NonNullable（不能为null）

/**
1

• Exclude null and undefined from T
  */
  type NonNullable = T extends null | undefined ? never : T;
  

  字面意思，不能为空

  使用举例

  export interface Student {
  
  name: string;
  
  age: number;
  
  }
  1
  2
  3

const student1: NonNullable = null

student1赋值为null会报错（在tsconfig.json配置文件中开启类型检查，“skipLibCheck”: false）

Parameters（参数）

/**
1

• Obtain the parameters of a function type in a tuple
  */
  type Parameters any> = T extends (…args: infer P) => any ? P : never;
  

  获取传入函数的参数组成的类型

  使用举例

  export interface Student {
  
  name: string;
  
  age: number;
  
  }
  1
  2
  3

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

const student1: Parameters

student1的类型为[name: string, age: number]

ConstructorParameters（构造参数）

/**
1

• Obtain the parameters of a constructor function type in a tuple
  */
  type ConstructorParameters any> = T extends abstract new (…args: infer P) => any ? P : never;
  

  获取传入构造函数的参数组成的类型

  使用举例

  export interface Student {
  
  name: string;
  
  age: number;
  
  }
  1
  2
  3

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

const student1: ConstructorParameters

student1的类型为[name: string, age: number]

ReturnType（返回类型）

/**
1

• Obtain the return type of a function type
  */
  type ReturnType any> = T extends (…args: any) => infer R ? R : any;
  

  获取传入函数的返回类型

  使用举例

  export interface Student {
  
  name: string;
  
  age: number;
  
  }
  1
  2
  3

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

const student1: ReturnType = {}

student1的类型为Student

InstanceType（构造返回类型、实例类型）

/**
1

• Obtain the return type of a constructor function type
  */
  type InstanceType any> = T extends abstract new (…args: any) => infer R ? R : any;
  

  获取传入构造函数的返回类型

  使用举例

  const Student = class {
  
  name: string;
  
  age: number;
  
  constructor (name: string, age: number) {
  
  this.name = name
  
  this.age = age
  
  }
  
  showInfo () {
  
  console.log('name: ', this.name, 'age: ', this.age);
  
  }
  
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

const student1: InstanceType = new Student(‘张三’, 20)

个人认为这是一个非常好用的内置类型，目前在前端项目中，class是用的越来越多了，在TS中，class其实也是可以用作类型声明空间的，用来描述对象类型，但是一般来说好像很少这样用的，一般用interface或者type居多

export class Student {

name: string;

age: number;

}

1
2
3
4

所以一般就是直接把class用作变量声明空间，但是对于 class new 出的实例，怎么描述它的类型呢，就如上文的，直接const student1: Student那是铁定会报错的，因为Student用作变量声明空间，没有用作类型声明空间（听起来好绕），这时候就可以用到InstanceType，完美解决问题

Uppercase（大写）

/**
1

• Convert string literal type to uppercase
  */
  type Uppercase = intrinsic;
  

  变大写

  使用举例

  export type StudentSexType = ‘male’ | ‘female’
  

const studentSex: Uppercase = ‘MALE’

Lowercase（小写）

/**
1

• Convert string literal type to lowercase
  */
  type Lowercase = intrinsic;
  

  变小写

  使用举例

  export type StudentSexType = ‘MALE’ | ‘FEMALE’
  

const studentSex: Lowercase = ‘’

Capitalize（首字母大写）

/**
1

• Convert first character of string literal type to uppercase
  */
  type Capitalize = intrinsic;
  

  首字母变大写

  使用举例

  export type StudentSexType = ‘male’ | ‘female’
  

const studentSex: Capitalize = ‘’

Uncapitalize（首字母小写）

/**
1

• Convert first character of string literal type to lowercase
  */
  type Uncapitalize = intrinsic;
  

  首字母变小写

  使用举例

  export type StudentSexType = ‘MALE’ | ‘FEMALE’
  

const studentSex: Uncapitalize = ‘’