布尔类型
我们用 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 = ['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。