笔记：TypeScript

基础类型

JS中的类型：
boolean、number、string、undefined、null、bigint、symbol、object。

const value: boolean = true;
const value: number = 1;
const value: string = '1';
const value: undefined = undefined;
const value: null = null;
const value: symbol = Symbol();
const value: bigint = 1n;
const value: object = {};

额外的类型：
①any相当于关闭了变量的TS语法检查。将any类型赋值给其他类型时，同样会关闭被赋值变量的语法检测。
②unknown只能赋值给unknown类型或any类型，不关闭语法检测。
③void用于返回undefined或null的函数。
④never用于抛出错误或死循环的函数。

const value: any = null;
const value: unknown = null;
function fun (): void {};
function fun (): never {};

数组类型：
①Tulpe定长数组中每一个元素都要指定基本类型。支持设置只读、可选。
②Array不定长数组有两种写法。

const value: [string, number?, ...any[]] = ['1',1];
const value: readonly [number] = [1];
const value: (number | string)[] = [1,2,3];        // 原生Array写法
const value: Array<number> = [1,2,3];              // 泛型Array写法

字面量类型：
数字字面量类型、字符串字面量类型、布尔字面量类型是number、string、boolean类型的子集，限定了变量只能是字面量类型指定的值。

value: 'x' | 'y' | 'z';
value: true | false;
value: 1 | 2 | 3;

函数类型：
对函数参数、函数返回值做类型限定。当函数参数个数不固定时，可以用rest数组收集。

function fun (arg?: string, ...rest: any[]): string {}
const fun: (arg: number) => number = function (arg: number): void {} 

枚举类型：
储存一组字符串或数字组成的常量，其中数字枚举还带有反向映射。

enum Enum {
    zero,
    one='one',
    two=4,
};
const value: Enum = Enum.zero;    // value = 0
const value: Enum = Enum.one;     // value = 'one'
const value: Enum = Enum[4];      // value = 'two'

接口类型

①接口设置对象属性的类型，多一些或少一些属性都是不允许的。
②一个接口只能有一个任意属性，且它的类型必须包含所有确定属性和可选属性的类型。
③支持设置只读、可选。
④extends继承其他接口类型。

interface IType1 {
    key1?: number;                 // 可选属性
    readonly key2: string;         // 只读属性
    [key3: string]: any;           // 任意属性 
}
interface IType2 extends IType1 {
    key4: () => void;              // 函数 
}

类型断言

①在编译阶段告诉编译器，这个变量的类型就是断言的类型，有两种写法。
②非空断言告诉编译器，变量是非null和非undefined类型，且一定会被赋值。

(<string>value)
(value as string)
value!                // 非空断言

类型别名 联合类型 交叉类型

①类型别名：可以自定义类型或接口的名字。
②联合类型：变量类型可以是众多类型中的一种。
③交叉类型：变量类型必须满足所有类型。

type IType = number | string;
type IType = boolean & any;

泛型

泛型是一个抽象类型，一般用T表示。表示变量的类型暂时不定，只有在调用的时候才确定他的值。

function fun<T, U> (arg1: [T, U]): [U, T] {} 

带泛型的函数在调用时，可以预先指定参数的类型，此时T即为string，U即为number。不指定时，TS会自动推测参数的类型，赋给泛型。

fun<string, number>() 

泛型语法

①extends泛型T由其他类型扩展而来，可以对泛型进行约束，保证T存在其他类型的属性。

function fun<T extends IType1, IType2> (arg: T): T {}

②typeof获取变量的类型，扩展了JS的typeof，能获取对象每个属性的类型。
③keyof获取某类型中所有建值，返回一个联合类型。

interface IType {
	key1: number;
	key2: string;
	key3: boolean;
}
type keys = keyof IType;     // "key1" | "key2" | "key3"
type types = typeof IType;   // "number" | "string" | "boolean"

④in遍历类型。

type IType<T> = {
  [key in keyof T]: number
}

⑤infer表示在extends条件语句中待推断的类型变量。下面的语句表示T是否是一个函数，如果是的话返回R类型，否则返回any类型。

type IType<T> = T extends () => infer R ? R : any;

⑥+/-添加/删除一些属性设置。

type IType<T> = {
 +readonly [p in keyof T]-?: T[p]
};

泛型工具

interface IType {
	a: string;
	b?: number;
	c: boolean;
};
type IType2 = 'a' | 'b' | 'c';

• Partial<T>将接口所有键名变成可选。

type Type = Partial<IType>;
// Type类型变为
type Type = {
	a?: string;
	b?: number;
	c?: boolean;
};

• Required<T>将接口所有键名变成必选。

type Type = Required<IType>;
// Type类型变为
type Type = {
	a: string;
	b: number;
	c: boolean;
};

• Readonly<T>将接口所有键名变成只读。

type Type = Readonly<IType>;
// Type类型变为
type Type = {
	readonly a: string;
	readonly b: number;
	readonly c: boolean;
};

• Pick<T, U>将T接口中的U键名列表提取出来。

type Type = Pick<IType, "a" | "b">;
// Type类型变为
type Type = {
	a: string;
	b?: number;
};

• Record<T, U>返回一个接口，其中所有为T联合类型的键名，类型转变为U类型。

type Type = Record<number | 'a', string>;
// Type类型变为
type Type = {
	[x: number]: string;
	a: string;
};

• Exclude<T, U>去除T联合类型中，与U联合类型重复的类型。

type Type = Exclude<IType2, "a" | "d">;
// Type类型变为
type Type = 'b' | 'c';

• Extract<T, U>提取T联合类型中，与U联合类型重复的类型。

type Type = Extract<IType2, "a" | "b">;
// Type类型变为
type Type = 'a';

• Omit<T, U>去除T接口中，U联合类型指定的键名。

type Type = Omit<IType, "a" | "b">;
// Type类型变为
type Type = {
	c: boolean;
};

• ReturnType<T>获取函数返回值的类型。
• NonNullable<T>过滤接口中的null和undefined类型的键名。
• Parameters<T>获取函数参数类型为元组。

type Type = ReturnType<IType>;
type Type = NonNullable<IType>;
type Type = Parameters<IType>