总结一些常用的 TS 内置类型，包含实现

Pick

字面意思:挑选，就是从一个较大类型中挑选出所需要的字段

使用

    type Person =  {
      name:string,
      age:number
    }
    type Baby  = Pick<Person,"name"> // { name:string}

原理

首先要限定 K 的范围，只能在 T 的 key 值组成的联合类型里面，然后遍历 K 值

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

Record

使用

字面意思:记录;一个 key 值对应一条 value 数据，key 值只能是 string | number | symbol

 type Person =  {
      name:string,
      age:number
 }
 type O = Record<string,number>
 const obj:O = {
      name: 12,
      password: 12
   };
   // 可以自由添加属性，但是要满足 string：number 这种条件
    obj.sex = 1

    type O1 = Record<"a" | 'b' ,Person>
    let c:O1 = {
       a: { name:'z',age:20 },
       b: { name:'z',age:20 },
    }

原理

keyof any 是 string | number | symbol 组成的联合类型

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

Exclude

使用

字面意思:排除; 从一个大的类型中，排除某些类型，基本上和 Pick 是反义一般都是总类型放在前面，需要操作的数据放到第二个参数上

// 第一个参数和第二个 都是联合类型
    type Baby  = Exclude<"name" | 'age',"name">
    let c:Baby = "age"

如果想在一个 interface 上去除某个 key 值，得到不带 key值的 interface 可以使用 Omit
不过可以使用 Exclude 模拟一下

// 原理：从一个对象中 排除一个 key 值，然后返回这个对象
// 1.从 Pick 中 挑出 除了 K 子集的参数
// 2. 获取 K 子集的参数
// 使用 {
//    [ P in keyof T]:P extends K ? never :P
// } 获得一个 { name:never,age:number }
//3. 使用 lookup 去除 never 获得 key 值

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

Omit

使用

字面意思:忽略; 从一个大的类型中，忽略某些类型，基本上和 Pick 是反义

type Person =  {
  name:string,
  age:number
}
type Baby  = Omit<Person,"name">
let f:Baby = {
  age:20
}

原理

// 把属于 K 的 排除
type Person =  {
  name:string,
  age:number
}
type MyOmit<T,K extends keyof T> =Pick<T, Exclude<keyof T,K>>
type Baby  = MyOmit<Person,"name"> // { }

Partial

字面意思：部分的，不完全的，所有属性变成可选属性

使用

type Person =  {
  name:string,
  age:number
}
type Baby  = Partial<Person>
let p1:Baby = {
    name:''
} // 可以省略 age

如果想让部分可选的话，可以实现一下原理就是先把所有属性都变成可选的把除了第二个参数之外的变成必填的取他们的交集

type PartialPart <T,K extends keyof T> = Partial<T> & Pick<T,Exclude<keyof T,K>>
type Baby  = PartialPart<Person,"age">
// age 是选填的
let f:Baby = {
  name:''
}

原理

type myPartial <T> = {
// 在  属性后面 加上 ?
  [P in keyof T]?:T[P]
}

Readonly

使用

type Person = Readonly< {
  name:string,
  age:number
}>

let f:Person = {
  name:'',
  age:20
}

f.name ="50" // error 不允许修改

原理

type  myReadOnly <T> = {
  readonly [K in keyof T]: T[K]
}

note:还有很多没写，比如returnType;Parameters;Uppercase;Lowercase;Capitalize 以后有时间补上，date:2022.5.27

TS 内置utilty 类型