Typescript 内置工具类型

 Partial<T> 将类型T的属性都变为可选属性，并构造一个新类型

1 interface Inter {
2     name: string
3     age:number
4 }
5 
6 type T = Partial<Inter> // { name?: string; age?: number; }

 Required<T>  将类型T的属性都变为必选属性，并构造一个新类型  和 Partial正好相反

interface Inter { 
    name?: string
    age?:number
}

type T = Required<Inter> // { name: string; age: number; }

interface A {
    x: number
    y: number
}
type T = Readonly<A>; // // { readonly x: number; readonly y: number; }
const a: T = { x: 0, y: 0 };
// a.x = 1;   // 编译错误！不允许修改
// a.y = 1;   // 编译错误！不允许修改

type K = 'x' | 'y';
type T = number;
type R = Record<K, T>; // { x: number; y: number; }
const a: R = { x: 0, y: 0 };  //  x' y 不能缺失任何一个

interface EmployeeType {
    id: number
    fullname: string
    role: string
}

let employees: Record<number, EmployeeType> = {
    0: { id: 1, fullname: "John Doe", role: "Designer" },
    1: { id: 2, fullname: "Ibrahima Fall", role: "Developer" },
    2: { id: 3, fullname: "Sara Duckson", role: "Developer" },
}

Record 实现源码:

/**
 * Construct a type with a set of properties K of type T
 */
type Record<K extends keyof any, T> = {
    [P in K]: T;
};

K中的所有属性值都转换为T类型，并将返回的新类型返回给proxyKType，K可以是联合类型、对象、枚举…

追加属性:

type K = 'name' | 'age' | 'sex'
type T = string
type Ks = K | 'height' // 追加属性
type R = Record<Ks, T>

const LILI: R  = {
    name: 'LILI', 
    sex: 'man',
    age: '12', 
    height:'178'
}

interface A { 
    x: number
    y: string
}
type T = Pick<A,'x'> // { x: number; }

interface SuperbUser {
  userId: number;
  macAddress: string;
  username: string;
  email: string;
  password: string;
  firstName: string;
  lastName: string;
  roles: ('Admin' | 'Editor' | 'Author')[]
};

type GuestUser = 'userId' | 'macAddress' | 'username'
type T = Pick<SuperbUser , GuestUser> // { userId: number; macAddress: string; username: string; }

  const USER: T = {
    userId: 1001,
    macAddress: '58962535',
    username:'XIANA'
  }

  // console.log(USER.roles) // 错误 Property 'roles' does not exist on type 'Pick<SuperbUser, GuestUser>'.

interface A { 
    x: number
    y: string
}
type T = Omit<A,'x'> // { y: number; }