TypeScript 学习笔记 — 类型补充void,any, tuple ,enum,nerver, Symbol , BigInt ,unknown（三）

unknown 类型

空值void 及（与Null 和 Undefined的区别）

JavaScript 没有空值（Void）的概念，在 TS中，用 void 表示没有任何返回值的函数：

function alertName(): void {

    alert('My name is Tom');

}

然而声明一个 void 类型的变量没什么用，因为只能将其赋值为 undefined 和 null：

let unusable: void = undefined;

Null 和 Undefined

let u: undefined = undefined;

let n: null = null;

区别：undefined 和 null 是所有类型的子类型。也就是说 undefined 类型的变量，可以赋值给所有类型的变量,包括 void 类型：

let num: number = undefined;

let u: undefined;

let str: string = u;

let vo: void= u;

// 编译通过

而 void 类型的变量不能赋值给其他类型的变量，只能赋值给 void 类型：

let u: void;

let num: number = u;  // Type 'void' is not assignable to type 'number'.

let vo: void = u;     // 编译通过

任意值Any

任意值（Any）用来表示允许赋值为任意类型。一个普通类型，在赋值过程中是不被允许改变类型的，any 类型，允许被赋值为任意类型。

let str: string = 'abc';

str = 123;

// Type 'number' is not assignable to type 'string'.

// -----------------------------------------------------------------

let str: any = 'abc';

str = 123;

// 编译通过

任意值可以访问任意属性和方法：

let anyThing: any = 'hello';

anyThing.setName('Jerry');

anyThing.setName('Jerry').sayHello();

anyThing.myName.setFirstName('Cat');

console.log(anyThing.myName);

console.log(anyThing.myName.firstName);

// 编译通过

未声明类型的变量：如果变量在声明时，未指定类型，那么会被识别为任意值类型：

let something;

something = 'seven';

something = 7;

// 等价于

let something: any;

something = 'seven';

something = 7;

元组类型

元组最重要的特性是可以限制数组元素的个数和类型,可以通过数组的方法进行新增。只能新增已经存在的类型。

let tuple: [name: string, age: number, male: boolean] = ["yya", 18, false];

let username = tuple[3]; // 此时添加新元素，但是取不到 会抛异常

console.log(tuple[3]); // error 长度为 "3" 的元组类型 "[string, number, boolean]" 在索引 "3" 处没有元素。

枚举类型

自带类型的对象, 枚举的值如果没有赋值，默认从 0 开始递增. 并且只能在值为数字的情况下反举。

作用：代码中常量、状态码、接口的定义、权限、标示位等可以采用枚举类型，提示友好,使用方便。

enum USER_ROLE { //

  USER = "a",

  ADMIN = 10,

  SUPER_ADMIN,

}

console.log(USER_ROLE.USER);

上述枚举 ts 代码，编译为 js,会生成一个对象，并实现反举(值为数字时)：

var USER_ROLE;

(function (USER_ROLE) {

  USER_ROLE["USER"] = "a";

  USER_ROLE[(USER_ROLE["ADMIN"] = 10)] = "ADMIN";

  USER_ROLE[(USER_ROLE["SUPER_ADMIN"] = 11)] = "SUPER_ADMIN";

})(USER_ROLE || (USER_ROLE = {}));

console.log(USER_ROLE.USER);

常量枚举

区别：常量枚举不能反举，一般用不到反举的情况下，都采用常量枚举，编译后的结果，不会生成对象，而是直接将值取出来。

写法上有些许不同，就是使用的const 关键字进行常量的声明

const enum USER_ROLE { //

  USER = "a",

  ADMIN = 10,

  SUPER_ADMIN,

}

console.log(USER_ROLE.USER);

编译为 js 代码，并不会生成一个对象：

console.log("a" /* USER_ROLE.USER */);

never 类型

任何类型的子类型,never 代表不会出现的值。不能把其他类型赋值给 never

1. 函数无法到达终点

// 循环不停止的情况

function whileTrue(): never {

  while (true) {}

}

// 或者抛出异常的情况

function throwError(): never {

  throw new Error();

}

function test() {

  throwError();

  let a = 1; // 此行代码会置灰，并提示 检测到无法访问的代码。

}

2.通常校验逻辑的完整性，可以利用 never 类型

function getResult(param: string | number | boolean) {

  if (typeof param === "string") {

    return param.split("");

  } else if (typeof param == "number") {

    return param.toString().split("");

  } else if (typeof param == "boolean") {

    return param.toString().split("");

  } else {

    // 如果达不到never 则可以正常的运行

    // 如果参数类型判断缺失boolean，则会抛出异常，不能将类型“boolean”分配给类型“never”。

    let n: never = param;

  }

}

Symbol 类型

Symbol 表示独一无二

const s1 = Symbol("key");

const s2 = Symbol("key");

console.log(s1 == s2); // false

BigInt 类型

当数值类型超出安全数值时，使用 bigInt 类型

const num1 = Number.MAX_SAFE_INTEGER + 1;

const num2 = Number.MAX_SAFE_INTEGER + 2;

console.log(num1 == num2); // true

let max: bigint = BigInt(Number.MAX_SAFE_INTEGER);

console.log(max + BigInt(1) === max + BigInt(2)); // false

unknown 类型

unknown 类型，任何类型都可以赋值为 unknown 类型。它是 any 类型对应的安全类型，

any：不进行类型检测

unknown：还是会检测，但在没有确定类型之前不能操作。(不能当做函数、类、对象来使用)

let unknown: unknown;

unknown = "18";

unknown.toString(); // 报错：对象的类型为 "unknown"

联合类型中的 unknown：联合类型与 unknown 都是 unknown 类型

type UnionUnknown = unknown | null | string | number; // type UnionUnknown = unknown

交叉类型中的 unknown:交叉类型与 unknown 都是其他类型

type interUnknown = unknown & null; // type interUnknown = null

never 是 unknown 的子类型

type isNever = never extends unknown ? true : false; // type isNever = true

keyof unknown 是 never

type key = keyof unknown; // type key = never