类型

TypeScript 的类型有很多，然而这里不会逐个进行解说。上面列出来的几种类型，有的你可能没听过、有的你可能没用过、有的你可能用过然而不晓得含意、有的你可能晓得含意然而不能和其余类型辨别···

Symbol

ES6 引入了一种新的原始数据类型 Symbol，示意举世无双的值，它是 JavaScript 语言的第七种数据类型。

应用 Symbol() 函数咱们能够申明一个 Symbol 变量，留神不能应用 new 命令，因为它是原始数据类型；Symbol 函数也能够承受一个字符串作为参数，次要是不便当 Symbol 转化为字符串时，比拟容易辨别，该传入的参数在 ES2019 中反对通过 description 这个实例属性来拜访。

Tuple（元组）

家喻户晓，对象、数组、枚举类型能够寄存多个数据；然而，对象和枚举寄存的数据以 key/value 模式存在，不具备排序等特效，数组中寄存的只能是同一类型数据；Tuple 类型能够看做是对象类型和数组类型特点的联合：

• 数据有序；
• 寄存不同类型数据；

在 JavaScript 中是没有元组的，元组是 TypeScript 中特有的类型，其⼯作⽅式相似 于数组。元组可⽤于定义 无限数量 的未命名属性的类型。每个属性都有⼀个关联的类型。使⽤元组时，必须 提供每个属性的值，能够通过索引拜访元素：

let tupleType: [string, boolean, number];
tupleType = ["hello", true, 2];

console.log(tupleType[0]); // hello
console.log(tupleType[1]); // true
console.log(tupleType[2]); //2

any（任意类型）

在 TypeScript 中，任何类型都能够被归为 any 类型。这让 any 类型成为了类型零碎的顶级类型（也被 称作全局超级类型）。

any 类型实质上是类型零碎的⼀个避难所，这给了开发者很⼤的⾃由：TypeScript 容许咱们 对 any 类型的值执⾏任何操作，包含赋值和被赋值，并且⽆需当时执⾏任何模式的查看。⽐如：

let value: any;
// 被赋值
value = 'hello world';
value = true;
value = [];
value = {};
value = 0;
// 赋值给其余变量
let temp: number;
temp = value;
// 操作属性 / 办法
value.toString();
value.length;
value();

• any 能够为任何类型，所以默认变量上的任何属性或者办法都能够找到一个类型（根底类型 / 自定义类型）对应上，所以查看没有问题；

unknown（不晓得什么类型）

就像所有类型都能够赋值给 any，所有类型也都能够赋值给 unknown。这使得 unknown 成为 TypeScript 类型零碎的另⼀种顶级类型（另⼀种是 any）；

对 value 变量的所有赋值都被认为是类型正确的。然而，尝试将类型为 unknown 的值赋值给其 他类型的变量时就会有意想不到的限度：

let value: unknown;
// 被赋值
value = 'hello world';
value = true;
value = [];
value = {};
value = 0;
// 赋值给其余变量
let temp: number;  // Error:Type 'unknown' is not assignable to type 'number'.
temp = value;

let temp2: any;
temp2 = value; // Success

let temp3: unknown;
temp3 = value; // Success

let temp4: string[]; // Error:Type 'unknown' is not assignable to type 'string[]'
temp4 = value;

// 操作属性 / 办法
value.toString(); // Error:Object is of type 'unknown'
value.length; // Error:Object is of type 'unknown'
value(); // Error:Object is of type 'unknown'

• unknown 类型只能被赋值给 any 类型和 unknown 类型自身：可能保 存任意类型值的容器能力保留 unknown 类型的值。
• value 变量类型为 unknown，进行查看的时候无奈确认变量类型，因而认为变量上的办法或者属性都是不确定的，查看不给通过。

void（没有任何类型）

void 能够了解为和 any 正好相同，示意没有任何类型，void 个别用于一个函数没用返回值时。当给一个变量定义为 void 类型时是没有任何作用，变量的值只能是undefined

let value:void;
value = 0; // Error:Type 'number' is not assignable to type 'void'.
value = undefined; // Success

null（空值类型）和 undefined（未定义类型）

TypeScript ⾥，undefined 和 null 两者有各⾃的类型的值别离为 undefined 和 null，并且只能是 undefined 和 null：

let value:null;
value = undefined;  // Error:Type 'undefined' is not assignable to type 'null'
value = null; //Success
value = 1; // Error:Type '1' is not assignable to type 'null'

let value:undefined;
value = undefined; //Success
value = null; // Error:Type 'null' is not assignable to type 'undefined'
value = 1; // Error:Type '1' is not assignable to type 'undefined'

Object、object 和{}（对象类型）

# TypeScript 中如何应用 Object、object 和{}？

Never

never 类型示意 不存在的值 的类型。never 类型用于：

• 抛出异样
• 不会有返回值的函数表达式或箭头函数表达式的返回值类型（无起点，始终执行上来！）。

function error(msg: string)msgever {throw new Error(msg);
}
function loop(): never {while (true) {// 始终执行上来}
}

使⽤ never 避免出现新增了联结类型没有对应的实现，⽬的就是写出类型相对平安的代码；能够利⽤ never 类型的个性对变量类型全⾯性查看：

// 定义 type a 为 string 或者 number 类型
type a = string | number;
// 办法 checkWithNever 用来检测参数是否是 type a，function checkWithNever(foo: a) {if (typeof foo === "string") {// 这⾥执行 string 类型的操作} else if (typeof foo === "number") {// 这⾥执行 number 类型的操作} else {
        // 在这⾥是 never 用来接管非 type a 的类型，并且会在编译时报错
        const check: never = foo;
    }
}
// 重写 type a 类型，然而没有批改 checkWithNever，导致 boolean 类型，⽆法赋值给 never 类型，执行后编译报错
type a = string | number | boolean;
const c: a = true;
checkWithNever(c); 
// Type 'boolean' is not assignable to type 'never'. 
// 'check' is declared but its value is never read.