除了前面javascript的7种原始数据类型，typescript还新增了枚举，接口，泛型，元组等数据类型

枚举

枚举（Enum）类型用于取值被限定在一定范围内的场景，比如一周只能有七天，颜色限定为红绿蓝等
枚举成员会被赋值为从 0 开始递增的数字，同时也会对枚举值到枚举名进行反向映射：

  1. enum Days {Sun, Mon, Tue, Wed, Thu, Fri, Sat};
  3. console.log(Days["Sun"] === 0); // true
  4. console.log(Days["Mon"] === 1); // true
  5. console.log(Days["Tue"] === 2); // true
  6. console.log(Days["Sat"] === 6); // true
  8. console.log(Days[0] === "Sun"); // true
  9. console.log(Days[1] === "Mon"); // true
  10. console.log(Days[2] === "Tue"); // true
  11. console.log(Days[6] === "Sat"); // true

手动赋值：

  1. enum Days {Sun = 7, Mon = 1, Tue, Wed, Thu, Fri, Sat};
  3. console.log(Days["Sun"] === 7); // true
  4. console.log(Days["Mon"] === 1); // true
  5. console.log(Days["Tue"] === 2); // true
  6. console.log(Days["Sat"] === 6); // true

上面的例子中，未手动赋值的枚举项会接着上一个枚举项递增
更多关于枚举的知识：https://www.cnblogs.com/zzalmo/p/11280529.html

接口

在 TypeScript 中，我们使用接口（Interfaces）来定义对象的类型。

  • 在面向对象语言中，接口（Interfaces）是一个很重要的概念，它是对行为的抽象，而具体如何行动需要由类（classes）去实现（implement）
  • TypeScript 中的接口是一个非常灵活的概念，除了可用于对类的一部分行为进行抽象以外，也常用于对对象的形状进行描述
    1. interface Person {
    2. name:string;
    3. age:number;
    4. }
    5. let tom:Person={
    6. name:‘Tom’,
    7. age:25
    8. };
    上面的例子中，我们定义了一个接口 Person，接着定义了一个变量 tom，它的类型是 Person。这样，我们就约束了 tom 的形状必须和接口 Person 一致。
    接口一般首字母大写，有的编程语言中会建议接口的名称加上 I 前缀。

可选属性：

  1. interface Person {
  2.     name: string;
  3.     age?: number;
  4. }
  6. let tom: Person = {
  7.     name: 'Tom'
  8. };

可选属性：

  1. interface Person {
  2. name:string;
  3. age?:number;
  4. [x:string]:any;//x可以是任意符合命名的单词
  5. }
  7. let tom:Person ={
  8. name:'Tom',
  9. gender:'male'
  10. };

可选属性：

  1. interface Person {
  2.     readonly id: number;
  3.     name: string;
  4.     age?: number;
  5.     [propName: string]: any;
  6. }
  8. let tom: Person = {
  9.     id: 89757,
  10.     name: 'Tom',
  11.     gender: 'male'
  12. };
  14. tom.id = 9527;
  16. // index.ts(14,5): error TS2540: Cannot assign to 'id' because it is a constant or a read-only property.

元组

数组合并了相同类型的对象，而元组（Tuple）合并了不同类型的对象。

定义一对值分别为 string 和 number 的元组：

  1. let sam:string[]=['sam','bob'] //数组
  2. let tom: [string, number] = ['Tom', 25];//元组

其实元组就是包含的不同类型元素的数组
也可以只赋值其中一项：

  1. let tom: [string, number];
  2. tom[0] = 'Tom';

但是当直接对元组类型的变量进行初始化或者赋值的时候，需要提供所有元组类型中指定的项

  1. let tom: [string, number];
  2. tom = ['Tom', 25];//正确
  3. tom = ['Tom'];//错误

当添加越界的元素时，它的类型会被限制为元组中每个类型的联合类型：

  1. let tom: [string, number];
  2. tom = ['Tom', 25];
  3. tom.push('male');//正确
  4. tom.push(true);//错误
  6. // Argument of type 'true' is not assignable to parameter of type 'string | number'.

泛型

泛型（Generics）是指在定义函数、接口或类的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性。

  1. function createArray<T>(length: number, value: T): Array<T> {
  2.     let result: T[] = [];
  3.     for (let i = 0; i < length; i++) {
  4.         result[i] = value;
  5.     }
  6.     return result;
  7. }
  9. createArray<string>(3, 'x'); // ['x', 'x', 'x']

上例中，我们在函数名后添加了 <T>，其中 T 用来指代任意输入的类型，在后面的输入 value: T 和输出 Array<T> 中即可使用了。

接着在调用的时候，可以指定它具体的类型为 string。当然，也可以不手动指定，而让类型推论自动推算出来：