• TypeScript 1.7
    • 支持 async/await 编译到 ES6 (Node v4+)
      • 例子
    • 支持同时使用 —target ES6 和 —module
      • 例子
    • this 类型
    • ES7 幂运算符
      • 举例
    • 改进对象字面量解构的检查
      • 举例
    • 装饰器 (decorators) 支持的编译目标版本增加 ES3

    TypeScript 1.7

    支持 async/await 编译到 ES6 (Node v4+)

    TypeScript 目前在已经原生支持 ES6 generator 的引擎 (比如 Node v4 及以上版本) 上支持异步函数. 异步函数前置 async 关键字; await 会暂停执行, 直到一个异步函数执行后返回的 promise 被 fulfill 后获得它的值.

    例子

    在下面的例子中, 输入的内容将会延时 400 毫秒逐个打印:

    1. "use strict";
    3. // printDelayed 返回值是一个 'Promise<void>'
    4. async function printDelayed(elements: string[]) {
    5.     for (const element of elements) {
    6.         await delay(400);
    7.         console.log(element);
    8.     }
    9. }
    11. async function delay(milliseconds: number) {
    12.     return new Promise<void>(resolve => {
    13.         setTimeout(resolve, milliseconds);
    14.     });
    15. }
    17. printDelayed(["Hello", "beautiful", "asynchronous", "world"]).then(() => {
    18.     console.log();
    19.     console.log("打印每一个内容!");
    20. });

    查看 Async Functions 一文了解更多.

    支持同时使用 —target ES6 和 —module

    TypeScript 1.7 将 ES6 添加到了 —module 选项支持的选项的列表, 当编译到 ES6 时允许指定模块类型. 这让使用具体运行时中你需要的特性更加灵活.

    例子

    1. {
    2.     "compilerOptions": {
    3.         "module": "amd",
    4.         "target": "es6"
    5.     }
    6. }

    this 类型

    在方法中返回当前对象 (也就是 this) 是一种创建链式 API 的常见方式. 比如, 考虑下面的 BasicCalculator 模块:

    1. export default class BasicCalculator {
    2.     public constructor(protected value: number = 0) { }
    4.     public currentValue(): number {
    5.         return this.value;
    6.     }
    8.     public add(operand: number) {
    9.         this.value += operand;
    10.         return this;
    11.     }
    13.     public subtract(operand: number) {
    14.         this.value -= operand;
    15.         return this;
    16.     }
    18.     public multiply(operand: number) {
    19.         this.value *= operand;
    20.         return this;
    21.     }
    23.     public divide(operand: number) {
    24.         this.value /= operand;
    25.         return this;
    26.     }
    27. }

    使用者可以这样表述 2 * 5 + 1:

    1. import calc from "./BasicCalculator";
    3. let v = new calc(2)
    4.     .multiply(5)
    5.     .add(1)
    6.     .currentValue();

    这使得这么一种优雅的编码方式成为可能; 然而, 对于想要去继承 BasicCalculator 的类来说有一个问题. 想象使用者可能需要编写一个 ScientificCalculator:

    1. import BasicCalculator from "./BasicCalculator";
    3. export default class ScientificCalculator extends BasicCalculator {
    4.     public constructor(value = 0) {
    5.         super(value);
    6.     }
    8.     public square() {
    9.         this.value = this.value ** 2;
    10.         return this;
    11.     }
    13.     public sin() {
    14.         this.value = Math.sin(this.value);
    15.         return this;
    16.     }
    17. }

    因为 BasicCalculator 的方法返回了 this, TypeScript 过去推断的类型是 BasicCalculator, 如果在 ScientificCalculator 的实例上调用属于 BasicCalculator 的方法, 类型系统不能很好地处理.

    举例来说:

    1. import calc from "./ScientificCalculator";
    3. let v = new calc(0.5)
    4.     .square()
    5.     .divide(2)
    6.     .sin()    // Error: 'BasicCalculator' 没有 'sin' 方法.
    7.     .currentValue();

    这已经不再是问题 - TypeScript 现在在类的实例方法中, 会将 this 推断为一个特殊的叫做 this 的类型. this 类型也就写作 this, 可以大致理解为 "方法调用时点左边的类型".

    this 类型在描述一些使用了 mixin 风格继承的库 (比如 Ember.js) 的交叉类型:

    1. interface MyType {
    2.     extend<T>(other: T): this & T;
    3. }

    ES7 幂运算符

    TypeScript 1.7 支持将在 ES7/ES2016 中增加的幂运算符: 和 =. 这些运算符会被转换为 ES3/ES5 中的 Math.pow.

    举例

    1. var x = 2 ** 3;
    2. var y = 10;
    3. y **= 2;
    4. var z =  -(4 ** 3);

    会生成下面的 JavaScript:

    1. var x = Math.pow(2, 3);
    2. var y = 10;
    3. y = Math.pow(y, 2);
    4. var z = -(Math.pow(4, 3));

    改进对象字面量解构的检查

    TypeScript 1.7 使对象和数组字面量解构初始值的检查更加直观和自然.

    当一个对象字面量通过与之对应的对象解构绑定推断类型时:

    • 对象解构绑定中有默认值的属性对于对象字面量来说可选.
    • 对象解构绑定中的属性如果在对象字面量中没有匹配的值, 则该属性必须有默认值, 并且会被添加到对象字面量的类型中.

    • 对象字面量中的属性必须在对象解构绑定中存在.当一个数组字面量通过与之对应的数组解构绑定推断类型时:

    • 数组解构绑定中的元素如果在数组字面量中没有匹配的值, 则该元素必须有默认值, 并且会被添加到数组字面量的类型中.

    举例

    1. // f1 的类型为 (arg?: { x?: number, y?: number }) => void
    2. function f1({ x = 0, y = 0 } = {}) { }
    4. // And can be called as:
    5. f1();
    6. f1({});
    7. f1({ x: 1 });
    8. f1({ y: 1 });
    9. f1({ x: 1, y: 1 });
    11. // f2 的类型为 (arg?: (x: number, y?: number) => void
    12. function f2({ x, y = 0 } = { x: 0 }) { }
    14. f2();
    15. f2({});        // 错误, x 非可选
    16. f2({ x: 1 });
    17. f2({ y: 1 });  // 错误, x 非可选
    18. f2({ x: 1, y: 1 });

    装饰器 (decorators) 支持的编译目标版本增加 ES3

    装饰器现在可以编译到 ES3. TypeScript 1.7 在 __decorate 函数中移除了 ES5 中增加的 reduceRight. 相关改动也内联了对 Object.getOwnPropertyDescriptor 和 Object.defineProperty 的调用, 并向后兼容, 使 ES5 的输出可以消除前面提到的 Object 方法的重复[1].