类型声明

对变量的类型进行指定

字符型数据

const test: string = "xxxxxxxxx";

数值型数据

const test: number = 100;

布尔型数据

const test: boolean = true;

数组型数据

• 指定整个数组内部数据类型

const test: string[] = ["xxx", "xxxx"]; //指定数组内只能存放字符型数据

• 使用泛型进行声明类型

const test: Array<string> = ["xxx", "xxxx"]; //指定数组内只能存放字符型数据

• 创建值类型字符串的数组

let test = new Array<string>(3).fill("xxx"); // fill 为其填充内容

• 使用元组声明类型

let test: [string, number, boolean];
test = ["xxx", 100, true];

对象型数据

• 声明对象类型，不指定对象内部数据的类型

let test: object;
test = { test: " xxx " }; //内部值未进行类型声明
test = {}; //字面量赋值
test = []; //数组是对象
test = Object.prototype; //原型对象

• 限定对象值类型

let test: { one: string; two: boolean };
test = { one: "xxx", two: true };

• 限定属性为非必填项

let test: { one: string; two: boolean; three?: boolean };
test = { one: "xxx", two: true };

索引签名

• 确定的索引名称

type TEST = {
  one: string;
  two: string;
};

let test: TEST = {
  one: "xxx",
  two: "xxx",
};

• 不确定的索引名称

type TEST = {
    [key: string]: keyof: any
}

let test: TEST = {
    one: 'xxx'
}

• 包含确定与不确定的索引名称

type TEST = {
    one: string,
    [key:string]: keyof: boolean
}

let test: TEST = {
    one: 'xxx',
    two: true
}

• 不确定的索引名称，包含指定的后缀

type TEST = {
    [key: `${string}TT`]: keyof: any
}

let test: TEST = {
    oneTT: 'xxxx'
}

• 使用 Record 工具类型

type TEST = Record<string, string>;

let test: TEST = {
  one: "xxx",
};

• 使用 Record 工具类型 + 联合类型

type TEST = Record<"one" | "two", string>;

let test: TEST = {
  one: "xxx",
  two: "xxx",
};

any

代表任意类型数据 关闭 TS 类型检测，并且当与其他数据发生交集时，关闭其他数据的 TS 类型检测

let test: any;
test = "xxx";
test = 100;
test = true;

unknown

代表未知类型数据 不能直接赋值给有明确类型的变量，必须结合as类型断言指定类型后，再进行赋值 仅关闭这个变量自身的 TS 类型检测，与其他数据发送交集时，不会影响其他数据的 TS 类型检测

let test: unknown = "xxxx";

let test2: string = test as string;

let test: string = "99";
let test2: number = test as unknown as number; //unknown做中间层转换

void

代表 null 或者 undefined 函数没有返回值时，可将类型设置为 void

let test: void = null;
let test2: void = undefined;
function test3(): void {} //函数返回值为 void ，设置后，函数不允许有返回结果

never

任何类型都不可以赋值给 never 函数抛出错误，或者无限循环时，返回值就是 never never 类型没有任何具体的值，比如 number 的值包含所有的数字，never 不包含任何值 never 可以作为任意其他类型的子类型，never extends string结果为 true

function test(  ): never {
    throw new error('xxx')
}

null & undefined

let test: null = null
let test2: undefined = undefined
let test3(  ): null | string {  }

union 联合类型

同时指定多个数据类型

let test: string | number = "xxxx";
test = 100;

let test1: (string | number)[] = ["xxx", 100];

Tuple 元组

let test: (number | boolean)[] = [];
test[0] = true; //正确

let test2: [number | boolean] = [];
test2[0] = true; //报错，第一个位置必须为number类型

交叉类型

使用 interface、object 等进行合并，组成新的数据类型

• 合并的多个类型没有冲突索引

interface A {
  one: string;
}
type B = { two: number };

let c: A & B = { one: "xxx", two: 100 };

• 合并的多个类型存在冲突索引

type A = { one: string; two: string };
type B = { two: boolean };

let c: A & B = {
  one: "xxx",
  two: "", //当类型冲突时，此时值为nerver
};

• 使用 Pick 类型工具解决冲突

type A = { one: string; two: string };
type B = { two: boolean };

type C = typeof B & Pick<typeof A, "two">;

let test: C = {
  one: "xxx",
  two: true,
};