TypeScript 学习笔记 — 类型补充void,any, tuple ,enum,nerver, Symbol , BigInt ,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
