TypeScript 1.7 est disponible et apporte le support des fonctions asynchrones
pour cibler des générateurs ES6

Microsoft a annoncé la disponibilité de TypeScript 1.7 en marge de l’Update 1 de son outil Visual Studio 2015. Cette nouvelle version apporte le support des fonctions Async pour gérer des éléments qui ont activé le support du générateur ES6 (comme node.js à partir de sa v4). Les fonctions peuvent désormais être utilisées avec le mot clé « async » en préfixe qui désigne une fonction asynchrone. Pour arrêter l’exécution jusqu’à ce que la fonction asynchrone ait rempli sa tâche, le mot clé « await » peut être utilisé. Voici un exemple en guise d’illustration :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// affichageRetarde est une 'TacheRemplie<void>'
 
async function affichageRetarde(elements: string[]) {
    for (const element of elements) {
        await delay(200);
        console.log(element);
    }
}
 
async function delay(milliseconds: number) {
    return new TacheRemplie<void>(resolve => {
        setTimeout(resolve, milliseconds);
    });
}
 
affichageRetarde(["Bonjour", "monde", "merveilleux", "asynchrone"]).then(() => {
    console.log();
    console.log("Tous les éléments ont été affichés!");
});
Microsoft explique être en train de travailler sur un support du couple async / await qui ciblera d’autres éléments qui pourraient ne pas disposer du support des générateurs ES6.

Cette mouture embarque également un nouveau type polymorphe this. Le type this peut être utilisé dans les classes et les interfaces pour représenter un type étant un sous-type du type du contenu (au lieu du type du contenu lui-même). Par exemple, considérons le module CalculatriceBasique :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
export default class CalculatriceBasique {
    public constructor(protected value: number = 0) { }
 
    public currentValue(): number {
        return this.value;
    }
 
    public addition(operand: number) {
        this.value += operand;
        return this;
    }
 
    public soustraction(operand: number) {
        this.value -= operand;
        return this;
    }
 
    public multiplication(operand: number) {
        this.value *= operand;
        return this;
    }
 
    public division(operand: number) {
        this.value /= operand;
        return this;
    }
}
Un utilisateur peut exprimer l’opération 2 x 5 +1 comme étant

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
import calc from "./CalculatriceBasique";
 
let v = new calc(2)
    .multiplication(5)
    .addition(1)
    .currentValue();
Cependant, supposons qu’un utilisateur veuille écrire une CalculatriceScientifique :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import CalculatriceBasique from "./CalculatriceBasique";
 
export default class CalculatriceScientifique extends CalculatriceBasique {
    public constructor(value = 0) {
        super(value);
    }
 
    public carre() {
        this.value = this.value ** 2;
        return this;
    }
 
    public sin() {
        this.value = Math.sin(this.value);
        return this;
    }
}
Parce que TypeScript infère le type CalculatriceBasique dans chaque méthode dans CalculatriceBasique qui retourne this, le système type va ignorer le fait qu’il avait CalculatriceScientifique à chaque fois qu’il va utiliser une méthode CalculatriceBasique.

TypeScript 1.7 a effectué un changement dans le type inféré this. Dans une classe, le type de la valeur this sera inféré au type this, et les affectations ultérieures des valeurs du type original peuvent ne pas fonctionner. Aussi, Microsoft a fourni un échantillon de code avec des solutions de contournement recommandées ainsi qu’une liste d’autres changements qui peuvent potentiellement occasionner une rupture sur GitHub.

TypeScript 1.7 ajoute es6 à la liste des options disponibles pour le –module flag et vous permet de spécifier la sortie du module lorsque vous visez ES6. Microsoft estime que cela apporte plus de flexibilité pour viser exactement les fonctionnalités que vous désirez dans des environnements d’exécution spécifiques.

Source : blog MSDN, problèmes avec TypeScript (GitHub)

Et vous ?

Utilisez-vous TypeScript ? Qu'en pensez-vous ?

Voir aussi :

Où en est TypeScript vis-à-vis de ECMAScript 6 ? Présentation de ce que TypeScript implémente pour le moment

TypeScript 1.6 disponible avec un support de la syntaxe JSX qui a été enrichie de nouveaux concepts