Typescript 从入门到放弃系列(十三)-内置类型

一.Partial 转化可选属性

interface Company {
  num: number;
}
interface Person {
  name: string;
  age: string;
  company: Company;
}
// type Partial<T> = { [K in keyof T]?: T[K] }; 实现原理
type PartialPerson = Partial<Person>;
// type PartialPerson = {
//   name?: string;
//   age?: string;
//   company?: Company;
// }

遍历所有的属性将属性设置为可选属性,但是无法实现深度转化!

interface Company {
  num: number;
}
interface Person {
  name: string;
  age: string;
  company: Company;
}
type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
};
type DeepPartialPerson = DeepPartial<Person>;
// type DeepPartialPerson = {
//   name?: string;
//   age?: string;
//   company?: DeepPartial<Company>;
// }

我们可以实现深度转化,如果值是对象继续深度转化。

二.Required 转化必填属性

interface Company {
  num: number;
}
interface Person {
  name: string;
  age: number;
  company: Company;
}
type PartialPerson = Partial<Person>;
type Required<T> = { [K in keyof T]-?: T[K] };
type RequiredPerson = Required<PartialPerson>;
const person: RequiredPerson = {
  name: "james",
  age: 18
};
// Property 'company' is missing in type '{ name: string; age: number; }' but required in type 'Required<Partial<Person>>'.ts(2741)

将所有的属性转化成必填属性

三.Readonly 转化仅读属性

interface Company {
  num: number;
}
interface Person {
  name: string;
  age: number;
  company: Company;
}
type Readonly<T> = { readonly [K in keyof T]: T[K] };
type RequiredPerson = Readonly<Person>;
const person: RequiredPerson = {
  name: "james",
  age: 18,
  company: {
    num: 1
  }
};
person.age = 20;
// Cannot assign to 'age' because it is a read-only property.

将所有属性变为仅读状态

四.Pick 挑选所需的属性

interface Company {
  num: number;
}
interface Person {
  name: string;
  age: number;
  company: Company;
}
type Pick<T, U extends keyof T> = { [P in U]: T[P] };
type PickPerson = Pick<Person, "name" | "age">;
// type PickPerson = {
//   name: string;
//   age: number;
// }

在已有类型中挑选所需属性

五.Record 记录类型

type Record<K extends keyof any, T> = { [P in K]: T };
let person: Record<string, any> = { name: "james", age: 18 };
// let person: Record<string, any>

实现 map 方法，我们经常用 record 类型表示映射类型

function map<T extends keyof any, K, U>(
  obj: Record<T, K>,
  callback: (item: K, key: T) => U
) {
  let result = {} as Record<T, U>;
  for (let key in obj) {
    result[key] = callback(obj[key], key);
  }
  return result;
}
const r = map({ name: "james", age: 18 }, (item, key) => {
  return item;
});

六.Omit 忽略属性

let person = {
  name: "james",
  age: 18,
  address: "深圳",
};
type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
type OmitAddress = Omit<typeof person, "address">;
// type OmitAddress = {
//   name: string;
//   age: number;
// }

忽略 person 中的 address 属性 (先排除掉不需要的 key，在通过 key 选出需要的属性)