Type compatibility in TypeScript is based in structural subtyping(aka, duck typing), contrast with nominal typing (in C# or Java)

  1. interface Named {
  2.     name: string;
  3. }
  5. class Person {
  6.     name: string;
  7. }
  9. let p: Named;
  10. // OK, because of structural typing
  11. // 如果在 C# 或者 Java 下这样就 gg 了
  12. p = new Person()

ts 因为是 js 的超集, js 里对象字面量和匿名函数满天飞, 选择 duck typing 而不是 nominal typing 最正常不过了

Starting out

The basic rule for TypeScript’s structural type system is that x is compatible with y if y has at least the same members as 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;

Note that y has an extra location property, but this does not create an error. Only members of the target type (Named in this case) are considered when checking for compatibility.

This comparison process proceeds recursively, exploring the type of each member and sub-member.

Comparing two functions

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

To check if x is assignable to y, we first look at the parameter list. Each parameter in x must have a corresponding parameter in y with a compatible type. Note that the names of the parameters are not considered, only their types. In this case, every parameter of x has a corresponding compatible parameter in y, so the assignment is allowed.

The second assignment is an error, because y has a required second parameter that x does not have, so the assignment is disallowed.

y = x 这种情况之所以被允许, 当然是为了写得更爽和兼容 js 啊, 想一想 forEach 的用法:

  1. let items = [1, 2, 3];
  3. // Don't force these extra parameters
  4. items.forEach((item, index, array) => console.log(item));
  6. // Should be OK!
  7. items.forEach(item => console.log(item));

Function Parameter Bivariance

看不懂

Optional Parameters and Rest Parameters

看不懂, 反正和上面的情况都是说一些边界情况, 能否把一个有些微变形的类型 B 认为是类型 A, compatibility

Fucntions with overloads

Enums

Enums are compatible with numbers, and numbers are compatible with enums
Enum values from different enum types are considered incompatible

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

Classes

Static members and constructors do not affect compatibility

  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, or `s = a;` is OK, because if `constructor` on the static side

private and protected members in classes

Private and protected members in a class affect their compatibility

Generics

  1. interface Empty<T> {
  2. }
  3. let x: Empty<number>;
  4. let y: Empty<string>;
  5. x = y;  // OK, because y matches structure of x
  7. interface NotEmpty<T> {
  8.     data: T;
  9. }
  10. let x: NotEmpty<number>;
  11. let y: NotEmpty<string>;
  12. x = y;  // Error, because x and y are not compatible
  14. // 没标明 type arguments, 会被当成 any
  15. let identity = function<T>(x: T): T {
  16.     // ...
  17. }
  18. let reverse = function<U>(y: U): U {
  19.     // ...
  20. }
  21. identity = reverse;  // OK, because (x: any) => any matches (y: any) => any

Advanced Topics

In TypeScript, there are two kinds of compatibility: subtype and assignment
These differ only in that assignment extends subtype compatibility with rules to allow assignment to and from any, and to and from enum with corresponding numeric values

更多的细节要看 ts 的 spec , 现在还看不起, 看也没什么卵用, 用起来才是真的