在TS中，可以指定数据类型。就是除了这个指定的数据类型，其他的数据类型都是不被允许的。

Boolean 布尔

  1. let isDone: boolean = false;
  3. // 错误的
  4. let isDone: boolean = "string";

Number 数字

和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;

String 字符串

  1. let name: string = "bob";
  2. name = "smith";
  3. let helloName: string = `hello ${name}`;

Array 数组

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

数组泛型
数组泛型可以规定数组内只允许有指定的数据类型的出现。

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

Tuple 元组

可以定义一个知道元素数量和数据类型的数组，元素类型可以不一样, 但是位置必须一样。

  1. let x: [string, number];
  2. x = ['hello', 10]; // OK
  3. x = [10, 'hello']; // Error
  4. x = ['hello', 10, 11]; // Error

Enum 枚举

使用枚举类型可以为一组数值赋予友好的名字。

  1. enum Color {Red, Green, Blue}
  2. let colorName: Color = Color.Green; // 1获取的是下标

枚举的下标是从0开始的，不过也是可以手动修改。

  1. enum Color {Red = 1, Green, Blue}
  2. let colorRed: string = Color[1]; // Red
  3. let colorGreen: string  = Color[2]; // Green
  4. let colorBlue: string  = Color[3]; // Blue
  6. // 全部手动赋值
  7. enum Color {Red = 1, Green = 2, Blue = 4};

Any 任意值

可以将它赋值给任何类型，它能让你避开类型检查。

  1. let variable: any = 'a string';
  2. variable = 5;
  3. variable = false;
  4. variable.someRandomMethod(); /* 行吧，也许运行的时候 someRandomMethod 是存在的 */

Void 空值

表示没有任何类型。它通常用作没有返回值的函数的返回类型。

  1. function warnUser(): void {
  2.     console.log("This is my warning message");
  3. }

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

  1. let unusable: void = undefined || null;

Null 和 Undefined

undefined 和 null 两者各自有自己的类型分别叫做 undefined 和 null。和 void 相似，它们的本身的类型用处不是很大，但是在联合类型中非常有用。

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

Never

never 类型表示的是那些永不存在的值的类型。 例如，never 类型是那些总是会抛出异常、或者根本就不会有返回值的函数的返回值类型。

  1. // 抛出异常
  2. function error(message: string): never {
  3.   throw new Error(message);
  4. }
  6. // 永远不能返回
  7. function continuousProcess(): never {
  8.   while (true) {
  9.       // ...
  10.   }
  11. }

Unknown

TypeScript 3.0 引入了 unknown (未知) 类型，它是与 any 类型对应的安全类型。任何东西都可以赋值给 unknown，但 unknown 不能赋值给除了它本身和 any 以外的任何东西。在没有先断言或指定到更具体类型的情况下，不允许对 unknown 进行任何操作。

  1. type I1 = unknown & null;    // null
  2. type I2 = unknown & string;  // string
  3. type U1 = unknown | null;    // unknown
  4. type U2 = unknown | string;  // unknown

Object

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

  1. declare function create(o: object | null): void;
  3. create({ prop: 0 }); // OK
  4. create(null); // OK
  6. create(42); // Error
  7. create("string"); // Error
  8. create(false); // Error
  9. create(undefined); // Error

类型别名

类型别名可以为现有类型提供替代名称，以便某些地方使用。构造它的语法如下：

  1. type Login = string;
  2. type int = number;

联合类型

让一个属性具有多种数据类型，名为 union (联合) 类型。

  1. type Password = string | number;

交叉类型

交叉类型是将多种类型叠加到一起成为一种类型。

  1. interface Person {
  2.   name: string;
  3.   age: number;
  4. }
  5. interface Worker {
  6.   companyId: string;
  7. }
  8. type Employee = Person & Worker;

类型断言

允许以任何方式覆盖其推断的类型。当你比编译器本身能更好地理解变量类型时，可以使用它。

  1. const friend = {};
  2. friend.name = 'John';  // Error! Property 'name' does not exist on type '{}'
  4. interface Person {
  5.   name: string;
  6.   age: number;
  7. }
  9. const person = {} as Person; // 或者 const person = <Person>{}; 因为在JSX中歧义，所以被as替代
  10. person.name = 'John';  // 正确