类型兼容性

    在使用基于名义类型的语言，比如C#或Java中，这段代码会报错，因为Person类没有明确说明其实现了Named接口。

    TypeScript的结构性子类型是根据JavaScript代码的典型写法来设计的。 因为JavaScript里广泛地使用匿名对象，例如函数表达式和对象字面量，所以使用结构类型系统来描述这些类型比使用名义类型系统更好。

    TypeScript的类型系统允许某些在编译阶段无法确认其安全性的操作。当一个类型系统具此属性时，被当做是“不可靠”的。TypeScript允许这种不可靠行为的发生是经过仔细考虑的。通过这篇文章，我们会解释什么时候会发生这种情况和其有利的一面。

    开始

    TypeScript结构化类型系统的基本规则是，如果要兼容y，那么y至少具有与x相同的属性。比如：

    1. interface Named {
    2.     name: string;
    3. }
    5. let x: Named;
    6. // y's inferred type is { name: string; location: string; }
    7. let y = { name: 'Alice', location: 'Seattle' };
    8. x = y;

    这里要检查y是否能赋值给x，编译器检查x中的每个属性，看是否能在y中也找到对应属性。 在这个例子中，y必须包含名字是name的string类型成员。y满足条件，因此赋值正确。

    检查函数参数时使用相同的规则：

    1. function greet(n: Named) {
    2.     console.log('Hello, ' + n.name);
    3. }
    4. greet(y); // OK

    注意，y有个额外的location属性，但这不会引发错误。 只有目标类型（这里是Named）的成员会被一一检查是否兼容。

    这个比较过程是递归进行的，检查每个成员及子成员。

    相对来讲，在比较原始类型和对象类型的时候是比较容易理解的，问题是如何判断两个函数是兼容的。 下面我们从两个简单的函数入手，它们仅是参数列表略有不同：

    1. let x = (a: number) => 0;
    2. let y = (b: number, s: string) => 0;
    4. y = x; // OK

    要查看x是否能赋值给y，首先看它们的参数列表。 x的每个参数必须能在y里找到对应类型的参数。 注意的是参数的名字相同与否无所谓，只看它们的类型。 这里，x的每个参数在中都能找到对应的参数，所以允许赋值。

    你可能会疑惑为什么允许忽略参数，像例子y = x中那样。 原因是忽略额外的参数在JavaScript里是很常见的。 例如，Array#forEach给回调函数传3个参数：数组元素，索引和整个数组。 尽管如此，传入一个只使用第一个参数的回调函数也是很有用的：

    下面来看看如何处理返回值类型，创建两个仅是返回值类型不同的函数：

    1. let x = () => ({name: 'Alice'});
    2. let y = () => ({name: 'Alice', location: 'Seattle'});
    4. x = y; // OK
    5. y = x; // Error, because x() lacks a location property

    类型系统强制源函数的返回值类型必须是目标函数返回值类型的子类型。

    函数参数双向协变

    当比较函数参数类型时，只有当源函数参数能够赋值给目标函数或者反过来时才能赋值成功。 这是不稳定的，因为调用者可能传入了一个具有更精确类型信息的函数，但是调用这个传入的函数的时候却使用了不是那么精确的类型信息。 实际上，这极少会发生错误，并且能够实现很多JavaScript里的常见模式。例如：

    1. enum EventType { Mouse, Keyboard }
    3. interface Event { timestamp: number; }
    4. interface MouseEvent extends Event { x: number; y: number }
    5. interface KeyEvent extends Event { keyCode: number }
    7. function listenEvent(eventType: EventType, handler: (n: Event) => void) {
    8.     /* ... */
    9. }
    11. // Unsound, but useful and common
    12. listenEvent(EventType.Mouse, (e: MouseEvent) => console.log(e.x + ',' + e.y));
    14. // Undesirable alternatives in presence of soundness
    15. listenEvent(EventType.Mouse, (e: Event) => console.log((e as MouseEvent).x + "," + (e as MouseEvent).y));
    16. listenEvent(EventType.Mouse, ((e: MouseEvent) => console.log(e.x + "," + e.y)) as (e: Event) => void);
    18. // Still disallowed (clear error). Type safety enforced for wholly incompatible types
    19. listenEvent(EventType.Mouse, (e: number) => console.log(e));

    你可以使用strictFunctionTypes编译选项，使TypeScript在这种情况下报错。

    比较函数兼容性的时候，可选参数与必须参数是可互换的。 源类型上有额外的可选参数不是错误，目标类型的可选参数在源类型里没有对应的参数也不是错误。

    当一个函数有剩余参数时，它被当做无限个可选参数。

    这对于类型系统来说是不稳定的，但从运行时的角度来看，可选参数一般来说是不强制的，因为对于大多数函数来说相当于传递了一些undefinded。

    有一个好的例子，常见的函数接收一个回调函数并用对于程序员来说是可预知的参数但对类型系统来说是不确定的参数来调用：

    1. function invokeLater(args: any[], callback: (...args: any[]) => void) {
    2.     /* ... Invoke callback with 'args' ... */
    3. }
    5. // Unsound - invokeLater "might" provide any number of arguments
    7. // Confusing (x and y are actually required) and undiscoverable
    8. invokeLater([1, 2], (x?, y?) => console.log(x + ', ' + y));

    函数重载

    对于有重载的函数，源函数的每个重载都要在目标函数上找到对应的函数签名。 这确保了目标函数可以在所有源函数可调用的地方调用。

    枚举

    类与对象字面量和接口差不多，但有一点不同：类有静态部分和实例部分的类型。 比较两个类类型的对象时，只有实例的成员会被比较。 静态成员和构造函数不在比较的范围内。

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

    类的私有成员和受保护成员会影响兼容性。 当检查类实例的兼容时，如果目标类型包含一个私有成员，那么源类型必须包含来自同一个类的这个私有成员。 同样地，这条规则也适用于包含受保护成员实例的类型检查。 这允许子类赋值给父类，但是不能赋值给其它有同样类型的类。

    泛型

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

    1. interface Empty<T> {
    2. }
    3. let x: Empty<number>;
    4. let y: Empty<string>;
    6. x = y;  // OK, because y matches structure of x

    上面代码里，x和y是兼容的，因为它们的结构使用类型参数时并没有什么不同。 把这个例子改变一下，增加一个成员，就能看出是如何工作的了：

    1. interface NotEmpty<T> {
    2.     data: T;
    3. }
    4. let x: NotEmpty<number>;
    5. let y: NotEmpty<string>;
    6. x = y;  // Error, because x and y are not compatible

    在这里，泛型类型在使用时就好比不是一个泛型类型。

    对于没指定泛型类型的泛型参数时，会把所有泛型参数当成any比较。 然后用结果类型进行比较，就像上面第一个例子。

    比如，

    子类型与赋值

    目前为止，我们使用了“兼容性”，它在语言规范里没有定义。 在TypeScript里，有两种兼容性：子类型和赋值。 它们的不同点在于，赋值扩展了子类型兼容性，增加了一些规则，允许和any来回赋值，以及enum和对应数字值之间的来回赋值。

    语言里的不同地方分别使用了它们之中的机制。 实际上，类型兼容性是由赋值兼容性来控制的，即使在和extends语句也不例外。

    更多信息，请参阅TypeScript语言规范.