一些类型的简写的语法糖

Partial

部分的，就是将必要的属性转变为可选属性

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

interface User {
  name: string;
  email: string;
  age: number;
}
let user: Partial<User> = {
  name: "jack",
  age: 18
};
//不报错

Required

用来将可选属性变为必须属性

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

interface User {
  name: string;
  age?: number;
}
let user: Required<User> = {
  name: "jack"
};
//报错
let user: Required<User> = {
  name: "jack",
  age: 18
};
不报错

Pick

用来指定某个类型的子类型，可以结合字面量类型和联合类型
从源码可以看出，第二个参数必须包含在第一个参数的键中

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

interface Parent {
  name: string;
  age: number;
}
type picked = "name" | "age";
let child: Pick<Parent, picked> = {
  name: "jack"
};
//报错
let child: Pick<Parent, picked> = {
  name: "jack",
  age: 18
};
//不报错

Record

用来给对象每一个键统一设置相同的类型
第一个参数是任何键名，第二个参数是要设置的类型，结合字面量类型和联合类型使用

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

interface People {
  name: string;
  age: number;
}
type FriendsNames = "jack" | "parker";
let friends: Record<FriendsNames, People> = {
  jack: {
    name: "jack",
    age: 18
  },
  parker: {
    name: "parker",
    age: 20
  }
};

Exclude

用来排除某一个对象中其他对象的键，相当于做差集

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

type c_d = Exclude<"a" | "b" | "c" | "d", "c" | "d" | "e">; //'c'|'d'
type c = Exclude<"a" | "b" | "c", "a" | "b">;//'c'
let C: c = "c";

Extract

提取，相当于做一个交集

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

type a_c = Extract<'a' | 'b' | 'c', 'a' | 'b' | 'd'>;  //'a'|'c'

ReturnType

用来获取函数的返回类型

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

使用

function foo(x: number): Array<number> {
  return [x];
}
type fn = ReturnType<typeof foo>; // -> number[]

ThisType

这个内置类型不是二次封装后的结果，而是底层实现后的结果
用来指定对象中的this的指向
一般用交叉类型来补充this的指向

interface Person {
  name: string;
  age: number;
  dosth: Function;
}
const obj: Person & ThisType<Person> = {
  name: "a",
  age: 18,
  dosth() {
    console.log(this.sss);
  }
};

InstanceType

用来获取构造函数类型的实例的类型

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

class C {
    x = 0;
    y = 0;
}
type T20 = InstanceType<typeof C>;  // C
type T21 = InstanceType<any>;  // any
type T22 = InstanceType<never>;  // any
type T23 = InstanceType<string>;  // Error
type T24 = InstanceType<Function>;  // Error

Parameters

用来获取函数参数组成的元组类型，顺序是不能错的

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

function foo(x: number, y: string): (string | number)[] {
  return [y, x, x];
}
type P = Parameters<typeof foo>;//[number,string]
let a: P = ["a", 1];//报错

NonNullChecks

用来排除类型中的null和undefined

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

使用这个类型需要开启一个选项

{
  "compilerOptions": {
    "strictNullChecks": true
  }
}

type T = string | number | null;
type U = NonNullable<T>; // -> string | number;
let a: U = "1";
let b: U = 1;
let c: U = undefined;//报错
let d: U = null;//报错

ConstructorParameters

用来获得类的constructor的参数获得类型组成的元组

type ConstructorParameters<T extends new (...args: any[]) => any> = 
    T extends new (...args: infer P) => any ? P : never;

class Person {
  private firstName: string;
  private lastName: string;
  constructor(firstName: string) {
    this.firstName = firstName;
  }
}
type P = ConstructorParameters<typeof Person>; //[string]

Omit

省略，表示从一个接口类型中，省略其中的某一个属性或者方法

type User = Omit<{ name: string; age: number }, "name">; 
let jack: User = {
  name: "jack",
  age: 18
};
//报错，因为省略了name
let jack: User = {
  age: 18
};
//通过

ThisParameterType

用来获取一个类型中this的类型

function toHex(this: Number) {
  return this.toString(16);
}
//尽管传入了this，但是这只是类型检查，因此运行的时候this还是window
function numberToString(n: ThisParameterType<typeof toHex>) {
  return toHex.apply(n);//这里的n的类型是number，因为上面传给了this number类型
}

OmitThisParameter

用来获取忽略this类型后的类型

function toHex(this: Number) {
  return this.toString(16);
}
type fiveToHex = typeof toHex;//(this:number)=>string;
type fiveToHex = OmitThisParameter<typeof toHex>;//()=>string;