TypeScript（ts）学习笔记（二）：基础类型

布尔类型

我们用 boolean 来表示布尔类型（开头是小写的）

const flag: boolean = false;

数字类型

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

字符串类型

const name: string = "hello world";

数组类型

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

const arr: number[] = [1, 2, 3]

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

const arr: Array<string> = ['4','5','6']

元组（Tuple）

元组类型与数组类型非常相似，元组表示一个已知元素数量和类型的数组，各元素的类型可以不同：

let x: [string, number] = ['1', 2]; // OK
x = [10, 'hello']; // Error
x[2] = 3; // Error
x.push(3); // OK
console.log(x[3]); // Error

枚举（enum）

枚举类型是对JavaScript标准数据类型的一个补充。像其它语言一样，使用枚举类型可以为一组数值赋予友好的名字。

数字枚举

enum Color { Red, White, Blue }
let c: Color = Color.White
console.log(c); // 1

默认是数字类型，并且从0开始累加，修改其中某个值，后面会根据前一个值进行累加：

enum Color { Red = 1, White, Blue }
let c: Color = Color.White
console.log(c); // 2

enum Color { Red, White=2, Blue = 1, Green }
console.log(Color); // 0 2 1 2

字符串枚举

枚举的值为字符串类型

enum Direction {
    North = "North",
    South = "South",
    East = "East",
    West = 'North',
}
console.log(Direction['Down']); // South
console.log(Direction.Left); // North

异构枚举

枚举的值是数字和字符串的混合

enum Person {
  age = 20,
  name = "zhangsan"
}

反向映射

enum Person {
  age = 20,
  name = "zhangsan"
}
console.log(Person.age); // 20
console.log(Person[20]); // 'age'
console.log(Person['zhangsan']); // Error （数字类型才有反向映射）

为什么数字枚举具有反向映射的特性，我们看一下编译之后的JavaScript就知道了

var Person;
(function (Person) {
    Person[Person["age"] = 20] = "age";
    Person["name"] = "zhangsan";
})(Person || (Person = {}));

常量枚举

const enum enum1 {
    a = "A",
    b = "B"
}
console.log(enum1['a']); // A
console.log(enum1['b']); // B

编译之后的JavaScript

console.log("A" /* 'a' */);
console.log("B" /* 'b' */);

Any类型

any类型是TypeScript针对编程时类型不明确的变量使用的一种数据类型：

let notSure: any = 4;
notSure = "hello world";
notSure = false;

包含不同类型数据的数组：

let list: any[] = [1, true, "free"];
list[1] = 100;

Void

它表示没有任何类型。当一个函数没有返回值时，通常它的返回值类型是 void：

function say(): void{
  console.log( "hello world!" )
}

只有undefined和null可以赋给void

Undefined 和 Null

undefined和null两者各自有自己的类型分别叫做undefined和null，和void相似，它们的本身的类型用处不是很大：

let u: undefined = undefined;
let v: void = void;

我们在正式项目最好启用 --strictNullChecks ，即 undefined和 null只能赋值给 any void 和它们自己。

Never

never 代表永远不存在的值，是其它任何类型的子类型。这意味着声明为never 类型的变量只能被 never类型所赋值，在函数中它通常表现为抛出异常或无法执行到终止点（例如无限循环）：

function loop(): never {
    while (true) {}
}
function error(message: string): never {
    throw new Error(message);
}

Object

object表示非原始类型，也就是除了number，string，boolean，symbol，null或undefined之外的类型。

let obj: object|null;
obj = enum2; // 枚举 ok
obj = 2; // Error
obj = "haha"; // Error
obj = null; 
obj = {name:"zhangsan"}

Unknow

unknown 是 TypeScript 3.0 引入的新类型，是any 类型对应的安全类型。
和any类型一样，它可以是任何类型：

let value: any; 
value = 1;  // OK
value = "2"; // OK
value = [1, 2, 3]; // OK
value = null; // OK

let value: unknow; 
value = 1; // OK
value = "2"; // OK
value = [1, 2, 3]; // OK
value = null; // OK

但是当 unknown 类型被确定是某个类型之前,它不能被进行任何操作：

let value: any; 
value(); // OK
value[0]; // OK
value.name; // OK
new value(); // OK

let value: unknow; 
value(); // Error
value[0]; // Error
value.name; // Error
new value(); // Error

any由于过于灵活的设定，导致它与 JavaScript没有太多区别，很容易产生一些低级错误，所以在很多场景下我们可以选择unknown 来代替any。