TypeScript 中的泛型

联合类型

interface Bird {
  name: string;
  fly(): void;
}
interface Person {
  name: string;
  talk(): void;
}
type BirdPerson = Bird | Person;
let p: BirdPerson = { name: "zfeng", fly() {} }; 
let p1: BirdPerson = { name: "zfeng", talk() {} };

交叉类型

interface Bird {
  name: string;
  fly(): void;
}
interface Person {
  name: string;
  talk(): void;
}
type BirdPerson = Bird & Person;
let p: BirdPerson = { name: "zhufeng", fly() {}, talk() {} };

内置条件类型

type Extract = T extends U ? T : never;
type Exclude = T extends U ? never : T;
type NonNullable = T extends null | undefined ? never : T;

type N = NonNullable;// 删除null和undifined;
type E = Exclude; // 排除关系 输出 string;
type I = Extract; // 包含关系 输出 number;

获取函数返回值的类型

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

function getUserInfo(name: string, age: number) {
  return { name, age };
}
type UserInfo = ReturnType;

const userA: UserInfo = {
  name: "zhufeng",
  age: 10,
};

获取函数参数的类型

type Parameters = T extends (...args: infer R) => any ? R : any;
function getUserInfo(name: string, age: number) {
  return { name, age };
}
type T1 = Parameters;  // [name: string, age: number]

提取

// pick 的原理
// type Pick = { [P in K]: T[P] };
interface Person {
  name: string;
  age: number;
  visiable: boolean;
}
type Person1 = Pick ;

取反

interface Person {
	name: string;
	age: number;
	visiable: boolean;
}
type Person1 = Pick ;
type Exclude = T extends U ? never : T;
type Omit = Pick>;
type Person2 = Omit;

交集

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

type C1 = { name: string; age: number; visible: boolean };
type C2 = { name: string; age: number; sex: number };

type C3 = Intersection;

差集

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

type C1 = { name: string; age: number; visible: boolean };
type C2 = { name: string; age: number; sex: number };

type C11 = Diff;

并集

// Compute的作用是将交叉类型合并
type Compute = A extends Function ? A : { [K in keyof A]: A[K] };
type Omit = Pick>;
type Merge = Compute< O1 & Omit>;
type C1C2 = Merge;