内置类型

常见内置类型

• Readonly 只读
• Partial 可选
• Requiled 必选
• Pick 选择
• Record 记录
• Exclude 排除
• Extract 取出
• Omit 省略
• NonNullable 非null和undefined
• Parametes 参数
• ConstructorParameters 构造函数参数
• ReturnType 返回值
• InstanceType 构造函数、实例的返回类型
• Uppercase 大写
• Lowercase 小写
• Capitalize 首字母大写
• Uncapitalize 首字母小写

映射类型

说明

只会作用于obj原本属性，不会引入新的属性

只读映射

通过Readonly关键字实现

ts
interface Prople {
	name: string
	age: number
}

type myPeople = Readonly<Prople> 
/*
type myPeople = {
	readonly name: string;
	readonly age: number;
}
*/

可选映射

说明

通过关键字Partial实现

ts
interface Prople {
	name: string
	age: number
}

type myPartial = Partial<Prople>

/*
	type myPartial = {
		name?: string | undefined;
		age?: number | undefined;
	}
*/

模拟原理示意

ts
type Partial<T> = { 
	[P in keyof T]?: T[P];
};

/*
Partial<T>: T 表示泛型
keyof T: 索引类型的查询操作符，返回类型T的所有公共属性字面量构成的联合类型

in 操作符: 用于判断某个属性是否在指定对象或其原型链中，如果存在则in运算符返回true
*/


// EG： 
interface A {
    id:string,
    name:string
}

type D = Partial<A>

/*
type Partial<T> = { 
	[P in keyof T]?: T[P];
};
*/

/*
keyof T : 索引类型的查询操作符，表示类型A的所有公共属性的字面量构成的联合类型
*/

// keyof A : 'id' | 'string'
let B:keyof A = 'id'  // sure
B = 'name' // sure
// B = 'age' // Type '"age"' is not assignable to type 'keyof A'.

/*
in 操作符: 用于判断某个属性是否在指定对象或其原型链中，如果存在则in运算符返回true
*/

必选映射

说明

和Partial相反，用于让可选属性变为必选属性, 通过Required实现

ts
Required<T>

模拟原理示意

ts
type Required<T> = { 
    [P in keyof T]-?: T[P]; 
};

条件类型

说明

条件类型是一种由条件表达式决定的类型

用途

实现类型过滤

普通条件类型

语法

若类型T可以被赋值给类型U，那么结果类型为X类型，否则为Y类型

ts
T extends U ? X : Y

EG

ts
type TypeName<T> =
	T extends string ? "string" :
	T extends number ? "number" :
	T extends boolean ? "boolean" :
	T extends undefined ? "undefined" :
	T extends Function ? "function" :
	"object";
type T1 = TypeName<string>//T1类型为字面量类型"string"  

分布式条件类型

语法

若类型T可以被赋值给类型U，那么结果类型为X类型，否则为Y类型

ts
(A | B) extends U ? X : Y
//相当于  
(A  extends U ? X : Y) | (B extends U ? X : Y)

Eg

ts
type TypeName<T> =
	T extends string ? "string" :
	T extends number ? "number" :
	T extends boolean ? "boolean" :
	T extends undefined ? "undefined" :
	T extends Function ? "function" :
	"object";
	
type T3 = TypeName<string | string[]>//TS类型为字面量类型"string"和字面量类型"object"的联合类型

Pick

说明

从T中选择部分类型组合成新类型

语法

ts
Pick<T, K>

模拟原理示意

ts
type Pick<T, K extends keyof T> = { 
    [P in K]: T[P]; 
};

/*
K extends keyof T： K继承于类型T的所有字面量类型构成的联合类型
*/

Record

说明

构造一个对象类型，其属性key是Keys,属性value是Type，被用于映射一个类型的属性到另一个类型

第一个参数接受预定义的新的属性，第二个参数接受已知的类型

语法

ts
interface Prople {
	name: string
	age: number
}

type myRecord = Record<"x"|"y",Prople>
/*
	type myRecord = {
		x: Prople;
		y: Prople;
	}
*/

模拟原理示意

ts
type Record<K extends keyof any, T> = { 
  [P in K]: T; 
};

Exclude

说明

从类型T中过滤掉可以赋值给类型U的类型

语法

ts
Exclude<T,U>

模拟原理示意

ts
type Diff<T, U> = T extends U ? never : T
/*
  // Diff被拆解为多个类型的联合类型  
  // Diff<"a", "a" | "e"> | Diff<"b", "a" | "e"> | Diff<"c", "a" | "e">
  // 字面量类型"a"可以被赋值给字面量联合类型"a" | "e"，所以返回never
  // 字面量类型"b"无法被赋值给字面量联合类型"a" | "e"，所以返回字面量类型"b"
  // 字面量类型"c"无法被赋值给字面量联合类型"a" | "e"，所以返回字面类类型"c"
  // never | "b" | "c"
  //最后类型为 "b" | "c"
*/

EG

ts
type A = 'id' | 'name'

type B = 'id' | 'name' | 'age'

const D:Exclude<B,A> // 类型为'age'

Extract

说明

与Exclude相反,从类型T中抽取出可以赋值给类型U的类型

语法

ts
Extract<T,U>

模拟原理示意

ts
type Extract<T, U> = T extends U ? T : never;

EG

ts
type A = 'id' | 'name'

type B = 'id' | 'name' | 'age'

const D:Extract<B,A> // 类型为"id" | "name"

Omit

说明

省略，传入一个类型，和此类型的几个属性，把传入的属性省略掉，剩余的类型组合为一个新类型

语法

ts
Omit<T,U>

模拟原理示意

ts
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

EG

ts
// type A = keyof any //类型为:  string | number | symbol

// type B = never | null
// type C = B extends A ? 'yes' : 'no'; // 'yes'


interface  A {
  name: string;
  age: number;
  id: number;
}

type B = 'name' | 'age'

const C: Omit<A, B> = { 'id':2233 }

/*
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
*/

// keyof any： string | number | symbol
// K extends keyof any:  泛型k必须可以赋值给`string | number | symbol`构成的联合类型

/*
Pick<T, Exclude<keyof T, K>>;
*/

/* 
Exclude<keyof T, K>

keyof T: 'name' | 'age' | 'id'

故而：
Exclude<keyof T, K>: 'id'
*/

/*
Pick<T, Exclude<keyof T, K>>变成了： Pick<T,'id'>

即根据Pick的定义，会从此处例子中的类型A中抽取属性'id'组成新的类型
*/

NonNullable

说明

过滤掉null类型和undefined类型

语法

ts
NonNullable<T>

模拟原理示意

ts
// 方法一
type NonNullable<T> = T & {}
/*
{}：排除了null和undefined以外的任何类型

T & {}: 返回的是类型T与{}的交叉类型
*/

// 方法二
type NonNullable<T> = T extends null | undefined ? never : T;

Parameters

说明

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

语法

ts
Parameters<T>

模拟原理示意

ts
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never

EG

ts
// 通过接口约束函数
interface myTtest {
    (x:number,y:number):number
}

let myFunction:myTtest= function(x,y){return x+y}

console.log(myFunction(1,2))

const user: Parameters<myTtest> = [1,2]// [x: number, y: number]

ConstructorParameters

说明

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

语法

ts
ConstructorParameters<T>

模拟原理示意

ts
type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never

EG

ts
interface A {
  name: string;
  age: number;
}

interface B {
  new (name: string, age: number): A
}

const C: ConstructorParameters<B> = ['1',2]// [name: string, age: number]

ReturnType

说明

可以获取函数返回值类型，接受一个函数作为参数

语法

ts
ReturnType<Fnction>

模拟原理示意

ts
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

EG

ts
type TB = ReturnType<() => string> 
//TB类型为string类型

InstanceType

说明

获取构造函数、实例的返回类型

语法

ts
InstanceType<T>

模拟原理示意

ts
type InstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any;

EG

ts
const user = 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);
  }
}

const user1: InstanceType<typeof user> = new user('张三', 20)
// const user2: user = new user('张三', 20) // Error: user作为值，此处却用为类型

Uppercase

说明

转大写

语法

ts
Uppercase<T>

模拟原理示意

ts
type Uppercase<S extends string> = intrinsic;

EG

ts
type userinfo = 'name' | 'age' | 'id'

let userID: Uppercase<userinfo> = 'ID'  // "NAME" | "AGE" | "ID"

Lowercase

说明

转小写

语法

ts
Lowercase<T>

模拟原理示意

ts
type Lowercase<S extends string> = intrinsic

EG

ts
type userinfo = "NAME" | "AGE" | "ID"

let userID: Lowercase<userinfo> = 'id'  // "name" | "age" | "id"

Capitalize

说明

首字母大写

语法

ts
Capitalize<T>

模拟原理示意

ts
type Capitalize<S extends string> = intrinsic

EG

ts
type userinfo = "name" | "age" | "id"

let userID: Capitalize<userinfo> = 'Id'  // "Name" | "Age" | "Id"

Uncapitalize

说明

首字母小写

语法

ts
Uncapitalize<T>

模拟原理示意

ts
type Uncapitalize<S extends string> = intrinsic

EG

ts
type userinfo = "Name" | "Age" | "Id"

let userID: Uncapitalize<userinfo> = 'id'  // "name" | "age" | "id"