作为入门Typescript的第一步，了解typescript中的类型必不可少，接下来我们就来详细介绍一下布尔值、数值、字符串、null、undefined、数组、any、nerver等常见类型。

布尔值

布尔值是最基础的数据类型，就是简单的true/false值，使用 boolean 定义布尔值类型

  1. let isDone: boolean = false;
  3. // error,new Boolean() 返回的是一个 Boolean 对象
  4. let createdByNewBoolean: Boolean = new Boolean(1);
  6. // ok,直接调用Boolean即可
  7. let createdByBoolean: boolean = Boolean(1);

数字

和JavaScript一样，TypeScript里的所有数字都是浮点数。 这些浮点数的类型是 number。 除了支持十进制和十六进制字面量，TypeScript还支持ECMAScript 2015中引入的二进制和八进制字面量

  1. let decLiteral: number = 6;
  2. let hexLiteral: number = 0xf00d;
  3. let binaryLiteral: number = 0b1010;
  4. let octalLiteral: number = 0o744;
  5. let notANumber: number = NaN;
  6. let infinityNumber: number = Infinity;

bigint

bigint 就是一个表示范围无穷大的整数类型

字符串

使用string表示文本数据类型,可以使用双引号（ “）或单引号（’）表示字符串，并且可以使用模版字符串，它可以定义多行文本和内嵌表达式

  1. let name: string = ’Gene‘;
  2. let age: number = 37;
  3. let sentence: string = `Hello, my name is ${ name }.
  5. I'll be ${ age + 1 } years old next month.`;

空值

使用void来表示没有任何返回值的函数

  1. function warn(): void {
  2.     console.log('warn')
  3. }

声明一个void类型的变量没有什么大用，因为你只能为它赋予undefined和null

  1. let unusable: void = undefined;

数组

有两种方式可以定义数组。规定元素类型后，元素必须为同一类型。
第一种，可以在元素类型后面接上[]，表示由此类型元素组成的一个数组

  2. let list: number[] = [1, 2, 3];

第二种方式是使用数组泛型，Array<元素类型>

  1. let list: Array<number> = [1, 2, 3];

另外常用的方法是用any 表示数组中允许出现任意类型

  1. let list: any[] = [1, 'foo', false, {a: 'bar'}];

元组

元组类型允许表示一个已知元素数量和类型的数组，各元素的类型不必相同

  1. let x: [string, number];
  2. // ok
  3. x = ['hello', 10]; 
  4. // error
  5. x = [10, 'hello'];

在ts 3.1版本之前，可以访问越界的元素，会使用联合类型替代，但是在3.1版本之后，已经不能访问越界元素了

  1. x[3] = 'world'; // OK, 字符串可以赋值给(string | number)类型
  2. console.log(x[5].toString()); // OK, 'string' 和 'number' 都有 toString
  3. x[6] = true; // Error, 布尔不是(string | number)类型

枚举

使用枚举类型可以为一组数值赋予友好的名字，enum类型是对JavaScript标准数据类型的一个补充

  1. enum Color {Red, Green, Blue}
  2. let c: Color = Color.Green;

默认情况下，从0开始为元素编号。 你也可以手动的指定成员的数值，如果指定某一数值，则从该数值开始自增1。或者全部手动赋值

  1. enum Color {Red = 1, Green, Blue}
  2. let c: Color = Color.Green;
  3. // 全部赋值
  4. enum Color {Red = 1, Green = 3, Blue = 4}
  5. let c: Color = Color.Green;
  7. // 未手动赋值的枚举项与手动赋值的重复也是允许的，但是最好不这么做
  8. enum Color {Red = 1, Green = 1, Blue = 4}
  9. let c: Color = Color.Green;

枚举成员会对枚举值到枚举名进行反向映射

  1. enum Color {Red, Green, Blue}
  2. let c: string = Color[1];
  4. // 相当于
  5. console.log(Color[0] === "Red")
  6. console.log(Color[1] === "Green")
  7. console.log(Color[2] === "Blue")
  8. console.log(Color["Red"] === 0)
  9. console.log(Color["Green"] === 1)
  10. console.log(Color["Blue"] === 2)

Null和Undefined

undefined和null两者各自有自己的类型分别叫做undefined和null,用处并不是很大

  1. let u: undefined = undefined;
  2. let n: null = null;

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

  1. // ok
  2. let num: number = undefined;
  4. // error
  5. let u: void;
  6. let num: number = u;

但是当你指定了—strictNullChecks标记，null和undefined只能赋值给void和它们各自。

Any

当你不知道变量的类型或者只知道一部分的话，any是非常有用的，比较适用于js改造为ts

  1. let notSure: any = 4;
  2. notSure = "maybe a string instead";
  4. let list: any[] = [1, true, "free"];
  5. list[1] = 100;

Never

never类型表示的是那些永不存在的值的类型。 例如， never类型是那些总是会抛出异常或根本就不会有返回值的函数表达式或箭头函数表达式的返回值类型； 变量也可能是 never类型，当它们被永不为真的类型保护所约束时。
never类型是任何类型的子类型，也可以赋值给任何类型；然而，没有类型是never的子类型或可以赋值给never类型（除了never本身之外）。 即使 any也不可以赋值给never

  1. // 返回never的函数必须存在无法达到的终点
  2. function error(message: string): never {
  3.     throw new Error(message);
  4. }
  5. // 推断的返回值类型为never
  6. function fail() {
  7.     return error("Something failed");
  8. }
  9. // 返回never的函数必须存在无法达到的终点
  10. function infiniteLoop(): never {
  11.     while (true) {
  12.     }
  13. }

void

对变量赋值void时，只相当于 undefined 类型的别名，我们一般用于函数的返回值声明。

  1. function error(message: string): void {
  2.     console.log(message);
  3. }

unknown

任何类型都是 unknown 的子类型，unknown 是所有类型的父类型,简单说就是任何值都可以赋值给类型是 unkown 的变量，与其对应的是，我们不能把一个 unkown 类型的值赋值给任意非 unkown 类型的值。

  1. let a: unknown = undefined
  2. a = Symbol('deep dark fantasy')
  3. a = {}
  4. a = false
  5. a = '114514'
  6. a = 1919n
  8. let b : bigint = a; // error