一、基础数据类型
1、数字类型
let count: number = 10;
// ES5：var count = 10;
复制代码2、字符串类型
let name: string = "小明";
// ES5：var name = '小明';
复制代码3、布尔值类型
let isShow: boolean = false;
// ES5：var isDone = false;
复制代码4、数组类型
let arr: number[] = [1, 2, 3];
// ES5：arr list = [1,2,3];
let arr: Array<number> = [1, 2, 3]; // Array<number>泛型语法
// ES5：var arr = [1,2,3];
复制代码5、枚举类型
我们可以定义一些带名字的常量
5-1、数字枚举
enum Direction {
NORTH,
SOUTH,
EAST,
WEST,
}
let dir: Direction = Direction.NORTH;// 0
默认情况下，NORTH 的初始值为 0，其余的成员会从 1 开始自动增长。
5-2、字符串枚举
enum Direction {
NORTH = "NORTH",
SOUTH = "SOUTH",
EAST = "EAST",
WEST = "WEST",
}
let dir: Direction = Direction.NORTH;// NORTH
5-3、异构枚举
enum Enum {
A,
B,
C = "C",
D = "D",
E = 8,
F,
}
console.log(Enum.A) //输出：0
console.log(Enum[0]) // 输出：A
复制代码6、Any类型
在TS中，任何类型都可以被归为 any 类型。这让 any 类型成为了类型系统的顶级类型（也被称作全局超级类型）。
let notSure: any = 666;
notSure = "Semlinker";
notSure = false;
在许多场景下，这太宽松了。使用 `any` 类型，可以很容易地编写类型正确但在运行时有问题的代码。
如果我们使用 `any` 类型，就无法使用 TypeScript 提供的大量的保护机制。
为了解决 `any` 带来的问题，TypeScript 3.0 引入了 `unknown` 类型。
复制代码7、Unknown 类型
就像所有类型都可以赋值给 `any`，所有类型也都可以赋值给 `unknown`。这使得 `unknown`
成为 TypeScript 类型系统的另一种顶级类型（另一种是 `any`）。
let value: unknown;
value = true; // OK
value = 42; // OK
value = "Hello World"; // OK
value = []; // OK
value = {}; // OK
value = Math.random; // OK
value = null; // OK
value = undefined; // OK
value = new TypeError(); // OK
value = Symbol("type"); // OK
----------------------------------
let value: unknown;
let value1: unknown = value; // OK
let value2: any = value; // OK
let value3: boolean = value; // Error
let value4: number = value; // Error
let value5: string = value; // Error
let value6: object = value; // Error
let value7: any[] = value; // Error
let value8: Function = value; // Error
unknown类型只能赋值给any或者unkonwn类型本身这，只有能够保存任意类型值的容器才能
保存 `unknown` 类型的值。毕竟我们不知道变量 `value` 中存储了什么类型的值。
let value: unknown;
value.foo.bar; // Error
value.trim(); // Error
value(); // Error
new value(); // Error
value[0][1]; // Error
将value变量类型设置为unknown后，这些操作都不再被认为是类型正确的。通过将any类型改变为unknown类型，
我们已将允许所有更改的默认设置，更改为禁止任何更改。
复制代码8、Tuple 类型
元组可用于定义具有有限数量的未命名属性的类型。每个属性都有一个关联的类型。使用元组时，必须提供每个属性的值
let tupleType: [string, boolean];
tupleType = ["我是字符串", true];
复制代码9、Void 类型
void 类型像是与 any 类型相反，它表示没有任何类型。当一个函数没有返回值时，你通常会见到其返回值类型是 void
// 声明函数返回值为void
function fn(): void {
console.log("emty");
}
//声明一个void类型的变量没有什么作用，因为它的值只能为undefined或null
let unusable: void = undefined;
复制代码10、Null 和 Undefined 类型
TypeScript中，`undefined` 和 `null` 两者有各自的类型分别为 `undefined` 和 `null`。
let u: undefined = undefined;
let n: null = null;
复制代码11、Never类型
never类型表示的是那些永不存在的值的类型。例如，never类型是那些总是
会抛出异常或根本就不会有返回值的函数表达式或箭头函数表达式的返回值类型。
// 返回never的函数必须存在无法达到的终点
function error(message: string): never {
throw new Error(message);
}
function infiniteLoop(): never {
while (true) {}
}
在 TypeScript 中，可以利用 never 类型的特性来实现全面性检查，具体示例：
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;
}
}
复制代码12、接口类型
interface Person {
name: string;
age?: number;//可选属性
}
let tom: Person = {
name: 'Tom',
age: 25 //可不存在
}
复制代码13、函数类型
function sum(x: number, y: number): number {
return x + y;
}
sum(1,2)
这是可以通过编译的，不过事实上，上面的代码只对等号右侧的匿名函数进行了类型定义，
而等号左边的 `mySum`，是通过赋值操作进行类型推论而推断出来的。
如果需要我们手动给 `mySum` 添加类型，则应该是这样：
let mySum: (x: number, y: number) => number = function (x: number, y: number): number {
return x + y;
};
复制代码二、TypeScript断言
类型断言好比其他语言里的类型转换，但是不进行特殊的数据检查和解构。它没有运行时的影响，只是在编译阶段起作用。
1、尖括号方法
let value: any = "this is a string";
let length: number = (<string>value).length;
复制代码2、as语法
let value: any = "this is a string";
let length: number = (value as string).length;
复制代码
