【TypeScript】基础数据类型

number（数字）

number类型可以表示双精度64位浮点值。

let binaryLiteral: number = 0b1010; // 二进制
let octalLiteral: number = 0o744;    // 八进制
let decLiteral: number = 6;    // 十进制
let hexLiteral: number = 0xf00d;    // 十六进制

string（字符串）

string类型可以表示单行字符串（使用单引号 ’ 或双引号 " ）；多行文本和内嵌表达式（使用反引号 ` ）

let name: string = "小田";
let years: number = 5;
let words: string = `${ name } 今年 ${ years } 岁了`;

boolean（布尔）

与其他语言一样，表示逻辑true和false

let flag: boolean= false;

数组

在元素类型后面加上 “[]” 来定义一个数组，数组中的元素类型是固定的。后面会提到一种不限元素类型的集合。

// 在元素类型后面加上[]
let arr: number[] = [1, 2];

// 或者使用数组泛型
let arr: Array<number> = [1, 2];

元组

元组类型用来表示已知元素数量和类型的数组，各元素的类型不必相同，对应位置的类型需要相同。可以使用下标来访问元素。

let x: [string, number];
x = ['小田', 1];    // 运行正常
x = [1, '小田'];    // 报错
console.log(x[0]);    // 输出 小田

enum（枚举）

枚举类型可以表示一些常量。
默认情况下，枚举的初始值为 0，其余的成员会从 1 开始自动增长。
但如果手动设置了枚举的初识值，那么其余成员会从手动设置的值开始增长。

enum sex {male, female, other};
console.log(sex.male);    // 输出 0
enum color {green = 2, blue, red};
console.log(color.red);    // 输出 4

any（任意）

声明为 any 的变量可以赋予任意类型的值。换句话说，any可以是任何类型。但是这种类型太宽松了，大量的使用any会导致TypeScript的类型保护机制失效，这违背了TypeScript的设计初衷。

let value: any;

value.trim(); // OK
value(); // OK
new value(); // OK
value[0][1]; // OK

Unknown（未知）

unknown 类型是 TS3 新增的类型，这个类型与 any 类型类似，可以设置任何的类型值，随后可以更改类型。
因此，我们可以将变量先设置为字符串类型，然后再将其设置为数字类型，如果事先不检查类型，使用any类型，调用了不存在的方法，编译时不会报错，代码运行时才会发现错误。
但是使用unknown 类型不一样，如果不进行类型判断，执行相关操作编译器就会报错。

unknown 类型不能赋值给除了 unknown 或 any 的其他任何类型，使用前必需显式进行指定类型，或是在有条件判断情况下能够隐式地进行类型推断的情况。

let a: unknown;
if(typeof a === "number"){
    const b: number = a; // 可以
}

let a: unknown;
const b: number = a; // 不可以，报错

使用 unknown 替代 any 会更加安全。

void（无返回值）

用于标识方法返回值的类型，表示该方法没有返回值。
需要注意的是，声明一个 void 类型的变量没有什么作用，因为它的值只能为 undefined 或 null。

function hello(): void {
    alert("Hello TypeScript");
}

null（空）与 Undefined（未定义）

默认情况下它们是所有类型的子类型，即可以赋值给任意类型，但如果打开了strictNullChecks，null 和 undefined 就只能赋值给 void 和它们各自的类型。

let u: undefined = undefined;
let n: null = null;

never（从不）

我们永远不能为 never 类型赋值，因此我们可以使用它对各种用例的函数施加限制。

// 返回never的函数必须存在无法达到的终点
function error(message: string): never {
  throw new Error(message);
}

function infiniteLoop(): never {
  while (true) {}
}

type Foo = string | number;

function controlFlowAnalysisWithNever(foo: Foo) {
  if (typeof foo === "string") {
    // 这里 foo 被收窄为 string 类型
  } else if (typeof foo === "number") {
    // 这里 foo 被收窄为 number 类型
  } else {
    // foo 在这里是 never
    const check: never = foo;
  }
}

假设后面有一天Foo的类型被修改了

type Foo = string | number | boolean;

但忘记了修改controlFlowAnalysisWithNever方法的控制流程，由于我们永远不能为 never 类型赋值，所以会有编译错误来提示我们。never的存在也是为了提高代码安全性。