keyof

获取类型内所有的 key，即所有属性名 , 获取的是一个 联合类型
这里类型指：通过 interface 或 type 定义的类型；通过 typeof xxx 返回的类型等。keyof 后面必须是类型，不能是具体的对象

interface IPeople {
    name:string,
    age?: number,
    sex: string,
  }
  
  type T = keyof IPeople

  // 等同于
  type T = "name" | "age" | "sex"

in

循环类型 一般循环的是 联合类型，把联合类型中每一个属性名赋值给 P

// 使用上面的 T 类型
  type TObj =  {
    [P in keyof T]: any
  }

  // 等同于
  type TObj = {
    name: any;
    age: any;
    sex: any;
  }

typeof

ts 中 typeof 是获取数据的类型，常用用于获取 对象、数组、函数、class、枚举等类型

const people = {
    name: 'liuyz',
    age: 18,
  }
  
  type INewPeople = typeof people
  // 等同于
  // type INewPeople = {
  //   name: number
  //   age: number
  // }
  
  const newPeople: INewPeople = {
    name: "zhi",
    age: 18,
  }
  
  type TKeys = keyof typeof newPeople
  // 等同于
  // type TKeys = "name" | "age"

Pick

从 T 类型中选取部分 K 类型，并返回新的类型，这里 T 常用于对象类型

 type Pick<T, K extends keyof T> = {
      [P in K]: T[P];
  };
// keyof T 获取 T 中所有的 key 属性
//K extends keyof T K 必须继承于 keyof T ,如果 K 中的属性有不属于 keyof T 的则会报错
interface IPeople {
    name:string,
    age?: number,
    sex: string,
  }
  
  type TPick = Pick<IPeople, 'name' | 'age'>
  
  // 等同于
  type TPick = {
    name: string;
    age?: number | undefined;
  }

Partial

将T中的所有属性设置为可选

type Partial<T> = {
      [P in keyof T]?: T[P];
  };
interface IPeople {
    name:string,
    age?: number,
    sex: string,
  }
  type TPartial = Partial<IPeople>
  
  // 等同于
  type TPartial = {
    name?: string | undefined;
    age?: number | undefined;
    sex?: string | undefined;
  }

Required

使 T 中的所有属性都变成必需的

interface IPeople {
    name:string,
    age?: number,
    sex: string,
  }
  type TRequired = Required<IPeople>

  // 等同于
  type TRequired = {
    name: string;
    age: number;
    sex: string;
  }

Readonly

将 T 中的所有属性设为只读

<!-- 源码 -->
  type Readonly<T> = {
    readonly [P in keyof T]: T[P];
  }

 interface IPeople {
    name:string,
    age?: number,
    sex: string,
  }
  type TReadonly = Readonly<IPeople>

  // 等同于
  type TReadonly = {
     readonly name: string;
     readonly age?: number | undefined;
     readonly sex: string;
  }

Exclude

从T中剔除可以赋值给U的类型

Extract

提取T中可以赋值给U的类型

Omit

// 就是在 User 的基础上，去掉 id 属性
type EditUser = Omit<User,"id">; 

Pick

从类型定义的属性中，选取指定一组属性，返回一个新的类型定义。

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

NonNullable

去除 null 和 undefined 后的新类型

type TType= number | null | undefined
  type TNonNullable = NonNullable<TType>
  // 等同于
  // type TNonNullable = number

typeof

• 自动生成对象的类型，如果对象上有类型则使用定义的类型