TypeScript - lizi

tsconfig#

compilerOptions#

target：生成的 JavaScript 文件里的语法应该遵循哪个 JavaScript 的版本
module：生成的 JavaScript 文件里如何导入其它文件
moduleResolution：采用何种方式解析（查找）TypeScript 文件中依赖的模块的位置

类型#

unknown#

表示一个未知类型，任意类型可以赋值给 unknown，但是 unknown 只能赋值给 unknown 和 any

never#

不存在的类型

extends#

为泛型添加类型约束

type Test<T extends string | number> = T[]

infer#

// T 是否继承自类型 U[] ，这里开始推断 U ，是的话右边等于 U，不是就等于 string
type Case1<T> =  T extends (infer U)[] ? U : string;

// 不符合推断，进入 Case1<T> 错误分支，最终类型为 string
type Type1 = Case1<number>;

// 符合推断，进入 Case1<T> 正确分支，最终类型为 number
type Type2 = Case1<number[]>;

in#

遍历

type MyReadonly<T> = {
    readonly [P in keyof T]: T[P]
}

interface User {
    id: number;
    age: number;
    sex: 0 | 1;
}

// MyReadonly<User> 等价于：

interface User {
    readonly id: number;
    readonly age: number;
    readonly sex: 0 | 1;
}

keyof#

获取对象的键值

interface User {
    id: number;
    age: number;
    sex: 0 | 1;
}

type P1 = keyof Person; // 'id' | 'age' | 'sex'

Record#

定义一个对象的 key 和 value 类型

type keys = "A" | "B" | "C";

const result: Record<keys, number> = {
    A: 1,
    B: 2,
    C: 3,
};

Omit 省略#

去除对象指定的属性

interface User {
    id: number;
    age: number;
    sex: 0 | 1;
}

type Person = Omit<User, "age" | "sex">;

interface PersonN {
    id: number;
}

// Omit 源码
type Omit<T, k extends keyof any> = Pick<T, Exclude<keyof T, K>>;

Pick 采集#

interface User {
    id: number;
    age: number;
    sex: 0 | 1;
}

type Person = Pick<User, "id" | "age">;

interface PersonN {
    id: number;
    age: number;
}

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

Partial#

使对象的属性都变成可选

interface User {
    id: number;
    age: number;
    sex: 0 | 1;
}

const obj: Partial<Person> = {
    id: 0,
};

interface PartialPerson {
    id?: number;
    age?: number;
    sex?: 0 | 1;
}

// Partial 源码
type Partial<T> = {
    [P in keyof T]?: T[P];
};

Required 必选的#

跟 Partial 相反，使对象的属性都变成必选

interface User {
    id: number;
    age: number;
    sex?: 0 | 1;
}

const obj: Required<Person> = {
    id: 0,
    age: 1,
    sex: 0,
};

interface RequiredPerson {
    id: number;
    age: number;
    sex: 0 | 1;
}

// Required 源码, -? 为移除可选属性
type Required<T> = {
    [P in keyof T]-?: T[P];
};

Readonly 转化只读#

使对象的属性都变成只读

interface User {
    id: number;
    age: number;
    sex?: 0 | 1;
}

const obj: Readonly<Person> = {
    id: 0,
    age: 1,
    sex: 0,
};

interface ReadonlyPerson {
    readonly id: number;
    readonly age: number;
    readonly sex: 0 | 1;
}

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

Extract 提取/包括#

interface User {
    id: number;
    age: number;
}

interface User2 {
    id: number;
    age: number;
    sex?: 0 | 1;
}

// User2 是否继承 User, 是返回 User2, 否返回 never
const obj: Extract<User2, User> = {
    id: 0,
    age: 1,
    sex: 0,
};

// Extract 源码
type Extract<T, U> = T extends U ? T : never;

Exclude 排除/不包括#

和 Extract 正好相反

interface User {
    id: number;
    age: number;
}

interface User2 {
    id: number;
    age: number;
    sex?: 0 | 1;
}

// User2 是否继承 User, 是返回 never, 否返回 User2
const obj: Exclude<User2, User> = {
    id: 0,
    age: 1,
    sex: 0,
};

// Exclude 源码
type Exclude<T, U> = T extends U ? never : T;