联合类型和交叉类型

    interface IPerson {
        name: string,
        id: number,
        type: string,
        age?: number | string
    }
    
    interface IUser {
        userName: string,
        password: string
    }
    
    // 交叉类型
    let someone: IPerson & IUser = {
        userName: '张三',
        password: '123456',
        name: 'zhangsan',
        id: 1,
        type: 'vip'
    }
    
    // 联合类型
    let someone: IPerson | IUser = {
        userName: '张三',
        password: '123456'
    }

上例中包含了两个类型（IUser和IPerson），如果是比较多的类型的话，可以使用type（类型别名）来定义

    // 标记一个类型
    type LoginAccpunt = IUser & IPerson;
    
    let userA: LoginAccpunt = {
        userName: '张三',
        password: '123456',
        name: 'zhangsan',
        id: 1,
        type: 'vip',
        age: 18
    }

一些高级特性 API

Partial
Required
Readonly
Pick
Record
Exclude<T, U>
Extract<T, U>
Omit<T, K extends keyof any>

Partial

Partial 是将属性变为可选属性。eg：当存在一个接口IUser（必选）和另一个接口 IOptionalUser（可选），二者具有相同属性，可以使用Partial实现

    // 实现
    type Partial<T> = {
        [P in keyof T]?: T[P]
    }
    // 使用
    interface IUser {
        name: string,
        age: number
    }
    
    type IOptionalUser = Partial<IUser>;

Required

Required是将属性变成必选属性，具体实现如下

    // 实现
    type Required<T> = {
        [P in keyof T]-?: T[P]
    }

    // 使用
    interface IOptionalUser {
        name?: string,
        age?: number
    }

    type IRequiredUser = Required<IUser>;

Readonly

Readonly是将属性变成必选属性，具体实现如下

    // 实现
    type Readonly<T> = {
        readonly [P in keyof T]: T[P]
    }

    // 使用
    interface IOptionUser {
        name?: string;
        age?: number;
    }
    
    type IReadonlyUser = Readonly<IOptionUser>

Record<K extends keyof any, T>

Record用来创建一个具有同类型属性值的对象

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

Exclude<T, U>

Exclude 是指从类型 T 中剔除所有可以赋值给 U 的属性，然后再构造一个新类型

    type excludeA = Exclude<'a' | 'b' | 'c', 'a'>;
    
   //相当于 excludeA = 'b' | 'c';

Pick

Pick是指摘取需要的类型

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

    interface IUser {
        userName: string,
        password: string,
        id: number,
        type: string,
        age: number,
        list: string[]
    }
    
    // 摘取需要的类型
    type Avator = Pick<IUser, 'userName' | 'type'>
    
    let mainInfo: Avator = {
        userName: '华安',
        type: 'vip',
    }

Omit

Omit主要用于剔除interface中的部分属性

    type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, k>>

    interface IUser {
        userName: string,
        password: string,
        id: number,
        type: string,
        age: number,
        list: string[]
    }
    
    // 剔除需要的类型
    type LoginUserType = Omit<IUser, 'list' | 'type' | 'id'>
    
    let loginData: LoginUserType = {
        userName: '华安',
        password: '9527',
        age: 23
    }

TypeScript高级用法学习笔记