类型兼容

  1. interface Named{
  2.   name:string
  3. }
  4. let x : Named
  5. let y = {
  6.   name:'jojo',
  7.   age:18
  8. }
  9. x = y

函数比较

  1. let x = (a:number)=> 0
  2. let y = (a:number,s:string)=> 0
  3. y = x
  4. // x = y //不兼容 报错

枚举

  • 枚举类型与数字类型兼容，并且数字类型与枚举类型兼容。不同枚举类型之间是不兼容的

    1. enum Status { Ready, Waiting }; 
    2. enum Color { Red, Blue, Green }; 
    3. let status = Status.Ready; 
    4. status = Color.Green; // Error

    类

  • 类与对象字面量和接口差不多，但有一点不同：类有静态部分和实例部分的类型。

  • 比较两个类类型的对象时，只有实例的成员会被比较。

  • 静态成员和构造函数不在比较的范围内。

    1. class Animal {
    2. feet: number;
    3. constructor(name: string, numFeet: number) { }
    4. }
    5. class Size {
    6. feet: number;
    7. constructor(numFeet: number) { }
    8. }
    9. let a: Animal;
    10. let s: Size;
    11. a = s;  // OK
    12. s = a;  // OK

    泛型

  • 因为TypeScript是结构性的类型系统，类型参数只影响使用其做为类型一部分的结果类型

    1. interface Empty<T> {}
    2. let x: Empty<number>;
    3. let y: Empty<string>;
    4. x = y;  // OK, because y matches structure of x
    5. let x: NotEmpty<number>; 
    6. let y: NotEmpty<string>;
    7. x = y; // error
    8. let identity = function <T>(x: T): T {
    9. // ...
    10. }
    11. let reverse = function <U>(y: U): U {
    12. // ...
    13. }
    14. identity = reverse; // ok