async/await support in ES6 targets (Node v4+)TypeScript now supports asynchronous functions for engines that have native support for ES6 generators, e.g. Node v4 and above.\nAsynchronous functions are prefixed with the async keyword;\nawait suspends the execution until an asynchronous function return promise is fulfilled and unwraps the value from the Promise returned.
In the following example, each input element will be printed out one at a time with a 400ms delay:
\n\nts\"use strict\";\n\n// printDelayed is a 'Promise<void>'\nasync function printDelayed(elements: string[]) {\n for (const element of elements) {\n await delay(400);\n console.log(element);\n }\n}\n\nasync function delay(milliseconds: number) {\n return new Promise<void>(resolve => {\n setTimeout(resolve, milliseconds);\n });\n}\n\nprintDelayed([\"Hello\", \"beautiful\", \"asynchronous\", \"world\"]).then(() => {\n console.log();\n console.log(\"Printed every element!\");\n});
For more information see async function reference reference.
\n--target ES6 with --moduleTypeScript 1.7 adds ES6 to the list of options available for the --module flag and allows you to specify the module output when targeting ES6.\nThis provides more flexibility to target exactly the features you want in specific runtimes.
\njson{\n \"compilerOptions\": {\n \"module\": \"amd\",\n \"target\": \"es6\"\n }\n}
this-typingIt is a common pattern to return the current object (i.e. this) from a method to create fluent-style APIs.\nFor instance, consider the following BasicCalculator module:
\ntsexport default class BasicCalculator {\n public constructor(protected value: number = 0) {}\n\n public currentValue(): number {\n return this.value;\n }\n\n public add(operand: number) {\n this.value += operand;\n return this;\n }\n\n public subtract(operand: number) {\n this.value -= operand;\n return this;\n }\n\n public multiply(operand: number) {\n this.value *= operand;\n return this;\n }\n\n public divide(operand: number) {\n this.value /= operand;\n return this;\n }\n}
A user could express 2 * 5 + 1 as
\ntsimport calc from \"./BasicCalculator\";\n\nlet v = new calc(2)\n .multiply(5)\n .add(1)\n .currentValue();
This often opens up very elegant ways of writing code; however, there was a problem for classes that wanted to extend from BasicCalculator.\nImagine a user wanted to start writing a ScientificCalculator:
\ntsimport BasicCalculator from \"./BasicCalculator\";\n\nexport default class ScientificCalculator extends BasicCalculator {\n public constructor(value = 0) {\n super(value);\n }\n\n public square() {\n this.value = this.value ** 2;\n return this;\n }\n\n public sin() {\n this.value = Math.sin(this.value);\n return this;\n }\n}
Because TypeScript used to infer the type BasicCalculator for each method in BasicCalculator that returned this, the type system would forget that it had ScientificCalculator whenever using a BasicCalculator method.
For instance:
\n\ntsimport calc from \"./ScientificCalculator\";\n\nlet v = new calc(0.5)\n .square()\n .divide(2)\n .sin() // Error: 'BasicCalculator' has no 'sin' method.\n .currentValue();
This is no longer the case - TypeScript now infers this to have a special type called this whenever inside an instance method of a class.\nThe this type is written as so, and basically means “the type of the left side of the dot in a method call”.
The this type is also useful with intersection types in describing libraries (e.g. Ember.js) that use mixin-style patterns to describe inheritance:
\ntsinterface MyType {\n extend<T>(other: T): this & T;\n}
TypeScript 1.7 supports upcoming ES7/ES2016 exponentiation operators: ** and **=.\nThe operators will be transformed in the output to ES3/ES5 using Math.pow.
\ntsvar x = 2 ** 3;\nvar y = 10;\ny **= 2;\nvar z = -(4 ** 3);
Will generate the following JavaScript output:
\n\njsvar x = Math.pow(2, 3);\nvar y = 10;\ny = Math.pow(y, 2);\nvar z = -Math.pow(4, 3);
TypeScript 1.7 makes checking of destructuring patterns with an object literal or array literal initializers less rigid and more intuitive.
\nWhen an object literal is contextually typed by the implied type of an object binding pattern:
\nWhen an array literal is contextually typed by the implied type of an array binding pattern:
\n\nts// Type of f1 is (arg?: { x?: number, y?: number }) => void\nfunction f1({ x = 0, y = 0 } = {}) {}\n\n// And can be called as:\nf1();\nf1({});\nf1({ x: 1 });\nf1({ y: 1 });\nf1({ x: 1, y: 1 });\n\n// Type of f2 is (arg?: (x: number, y?: number) => void\nfunction f2({ x, y = 0 } = { x: 0 }) {}\n\nf2();\nf2({}); // Error, x not optional\nf2({ x: 1 });\nf2({ y: 1 }); // Error, x not optional\nf2({ x: 1, y: 1 });
Decorators are now allowed when targeting ES3.\nTypeScript 1.7 removes the ES5-specific use of reduceRight from the __decorate helper.\nThe changes also inline calls Object.getOwnPropertyDescriptor and Object.defineProperty in a backwards-compatible fashion that allows for a to clean up the emit for ES5 and later by removing various repetitive calls to the aforementioned Object methods.