类型保护

    TypeScript 熟知 JavaScript 中 和 typeof 运算符的用法。如果你在一个条件块中使用这些，TypeScript 将会推导出在条件块中的的变量类型。如下例所示，TypeScript 将会辨别 string 上是否存在特定的函数，以及是否发生了拼写错误：

    1. class Foo {
    2.   foo = 123;
    3.   common = '123';
    4. }
    6. class Bar {
    7.   bar = 123;
    8.   common = '123';
    9. }
    11. function doStuff(arg: Foo | Bar) {
    12.   if (arg instanceof Foo) {
    13.     console.log(arg.foo); // ok
    14.     console.log(arg.bar); // Error
    15.   }
    16.   if (arg instanceof Bar) {
    17.     console.log(arg.foo); // Error
    18.     console.log(arg.bar); // ok
    19. }
    22. doStuff(new Bar());

    TypeScript 甚至能够理解 else。当你使用 if 来缩小类型时，TypeScript 知道在其他块中的类型并不是 if 中的类型：

    1. interface A {
    2.   x: number;
    3. }
    5. interface B {
    6.   y: string;
    7. }
    9. function doStuff(q: A | B) {
    10.   if ('x' in q) {
    11.     // q: A
    12.   } else {
    13.     // q: B
    14.   }
    15. }

    当你在联合类型使里使用字面量类型时，你可以检查它们是否有区别：

    1. // 仅仅是一个 interface
    2. interface Foo {
    4.   common: string;
    6. interface Bar {
    7.   bar: number;
    8.   common: string;
    9. }
    11. // 用户自己定义的类型保护！
    12. function isFoo(arg: Foo | Bar): arg is Foo {
    13.   return (arg as Foo).foo !== undefined;
    14. }
    16. // 用户自己定义的类型保护使用用例：
    17. function doStuff(arg: Foo | Bar) {
    18.   if (isFoo(arg)) {
    19.     console.log(arg.foo); // ok
    20.     console.log(arg.bar); // Error
    21.   } else {
    22.     console.log(arg.foo); // Error
    23.     console.log(arg.bar); // ok
    24.   }
    25. }
    27. doStuff({ foo: 123, common: '123' });