Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

TypeScript Discussion :

TypeScript 1.8 disponible


Sujet :

TypeScript

  1. #1
    Rédacteur/Modérateur

    TypeScript 1.8 disponible
    TypeScript 1.8 disponible en bêta


    L'équipe TypeScript de Microsoft a annoncé récemment la sortie de la version 1.8 de son compilateur TypeScript en bêta.

    Sans qu'il y ait de nouveautés fondamentales, il s'agit davantage d'un ensemble d'améliorations de l'existant qui pourront néanmoins être utiles pour nombre de développeurs. Cela montre en outre que ce langage continue de mûrir tant sur le plan de la syntaxe et de la sémantique que sur le plan de l'outillage et des ponts avec d'autres briques du Web.


    Paramètres de types comme contraintes

    Tout d'abord, le langage en lui-même s'améliore au niveau de son système de typage. Avec cette nouvelle version, il est désormais possible qu'un type générique fasse référence à un autre type générique d'une même liste (F-Bounded Polymorphism), chose qui n'était pas possible auparavant.

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    function assign<T extends U, U>(target: T, source: U): T {
        for (let id in source) {
            target[id] = source[id];
        }
        return target;
    }
     
    let x = { a: 1, b: 2, c: 3, d: 4 };
    assign(x, { b: 10, d: 20 });
    assign(x, { e: 0 });  // Error


    Ci-dessus, le type générique T fait référence au type générique U dans la même liste de contraintes.


    Types de littéraux

    Un ensemble de littéraux peuvent désormais constituer un type à part entière, sans que cela passe par la construction enum, plutôt réservée pour des symboles associés à des nombres.

    Cela permet entre autre de détecter des fautes de frappes dans des chaînes de caractères qu'il n'était pas possible de détecter auparavant (et dans d'autres langages aussi).

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    interface AnimationOptions {
        deltaX: number;
        deltaY: number;
        easing: "ease-in" | "ease-out" | "ease-in-out";
    }
     
    // Error: Type '"ease-inout"' is not assignable to type '"ease-in" | "ease-out" | "ease-in-out"'
    new UIElement().animate({ deltaX: 100, deltaY: 100, easing: "ease-inout" });


    Ci-dessus, la valeur "ease-inout" n'étant pas admise dans le domaine de type, sera détectée comme une erreur.


    Inférence de type améliorée pour les unions/intersections

    L'union et l'intersection de types précédemment introduites dans le langage voient leur inférence de type améliorée.

    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
    type Maybe<T> = T | void;
     
    function isDefined<T>(x: Maybe<T>): x is T {
        return x !== undefined && x !== null;
    }
     
    function isUndefined<T>(x: Maybe<T>): x is void {
        return x === undefined || x === null;
    }
     
    function getOrElse<T>(x: Maybe<T>, defaultValue: T): T {
        return isDefined(x) ? x : defaultValue;
    }
     
    function test1(x: Maybe<string>) {
        let x1 = getOrElse(x, "Undefined");         // string
        let x2 = isDefined(x) ? x : "Undefined";    // string
        let x3 = isUndefined(x) ? "Undefined" : x;  // string
    }
     
    function test2(x: Maybe<number>) {
        let x1 = getOrElse(x, -1);         // number
        let x2 = isDefined(x) ? x : -1;    // number
        let x3 = isUndefined(x) ? -1 : x;  // number
    }



    Gardes de type basées sur this

    Alors que les gardes de type personnalisée pouvaient être des fonctions définies par l'utilisateur, il est dorénavant possible d'en faire à partir de méthodes de classe, autorisant l'utilisation du mot-clé this.

    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
    class FileSystemObject {
        isFile(): this is File { return this instanceof File; }
        isDirectory(): this is Directory { return this instanceof Directory;}
        isNetworked(): this is (Networked & this) { return this.networked; }
        constructor(public path: string, private networked: boolean) {}
    }
     
    class File extends FileSystemObject {
        constructor(path: string, public content: string) { super(path, false); }
    }
    class Directory extends FileSystemObject {
        children: FileSystemObject[];
    }
    interface Networked {
        host: string;
    }
     
    let fso: FileSystemObject = new File("foo/bar.txt", "foo");
    if (fso.isFile()) {
        fso.content; // fso is File
    }
    else if (fso.isDirectory()) {
        fso.children; // fso is Directory
    }
    else if (fso.isNetworked()) {
        fso.host; // fso is networked
    }


    Ci-dessus, grâce aux méthodes isFile(), isDirectory() et isNetworked(), l'inférence de type pourra déterminer si l'objet en question est respectivement un File, Directory ou Networked dans un bloc conditionnel donné.

    Cela généralise par conséquent la notion de garde de type non seulement aux unions et aux intersections de type, mais également aux classes, faisant de ce concept un élément central dans l'inférence de type dans un contexte de polymorphisme.


    Autorisation des let/const capturés dans les boucles

    La définition de let ou const dans des boucles pouvaient poser problème lorsque le symbole en question était référencé dans une fonction anonyme fléchée. Avec cette nouvelle version de TypeScript, ce problème a été corrigé.

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    let list = [];
    for (let i = 0; i < 5; i++) {
        list.push(() => i);
    }
     
    list.forEach(f => console.log(f()));


    Donnant comme résultat :
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    0
    1
    2
    3
    4




    Analyse du flux de contrôle

    Jusque-là, en dehors du contrôle sur les types, le compilateur TypeScript ressemblait plus à un simple transpilateur d'un langage vers un autre. Désormais, avec cette version 1.8, le compilateur de Microsoft analyse le programme pour détecter la présence de code inaccessible, de symboles inutilisés, de retours implicites de fonction (--noImplicitReturns), ou l'absence de break à la fin d'un bloc case, sauf si ce bloc case est vide (--noFallthroughCasesInSwitch).



    JavaScript dans la compilation TypeScript

    On notera la possibilité d'inclure directement dans un projet TypeScript des fichiers JavaScript. Ceci sans avoir à renommer l'extension et sans être pollué par les innombrables messages d'erreurs et d'avertissements lors de la compilation, simplement en utilisant l'option allowJs soit dans la ligne de commande, soit dans le fichier tsconfig.json.

    Il est du coup possible de transpiler du JavaScript ES6 en ES5 grâce au compilateur TypeScript.
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    > tsc --allowJs --outDir out target_file.js



    Support étendu de ReactJS

    TypeScript améliore le support de React en autorisant les composants de fonctions sans état.

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    // Use parameter destructuring and defaults for easy definition of 'props' type
    const Greeter = ({name = 'world'}) => <div>Hello, {name}!</div>;
     
    // Properties get validated
    let example = <Greeter name='TypeScript 1.8' />;


    La déclaraction des types Props a également été simplifiée tout comme le support de la colorisation syntaxique dans Visual Studio 2015.


    Modularité

    Des améliorations significatives autour des modules ont été réalisées. Par exemple, il est maintenant possible d'étendre un module ou le contexte global à partir d'un autre module, ce qui n'était pas possible auparavant, assez bizarrement d'ailleurs.

    Le compilateur TypeScript peut également concaténer des modules AMD et SystemJS.


    source : Compte Github officiel de TypeScript


    Que pensez-vous de ces nouvelles fonctionnalités ?
    Quelle(s) fonctionnalité(s) auriez-vous souhaité en plus de celles-ci ?
    Tutoriels et FAQ TypeScript

  2. #2
    Responsable Jeux-Concours

    TypeScript 1.8 : types de littéraux, let/const, support de React
    TypeScript 1.8 : types de littéraux, let/const, support de React
    pour le sur-ensemble de JavaScript


    L'équipe TypeScript de Microsoft a annoncé récemment la sortie de la version 1.8 de son compilateur TypeScript quelques semaines seulement après la sortie de la version bêta.

    L'actualité à ce sujet évoquait des fonctionnalités clés disponibles pour les utilisateurs. Comme le JavaScript dans la compilation TypeScript, le support étendu de React, etc.

    Aujourd'hui, l'équipe insiste sur l'amélioration de la modularité, le système renforcé des types de littéraux et une meilleure analyse du flux de contrôle.

    Nous avons déjà présenté ces évolutions, je ne vais donc pas entrer à nouveau dans les détails et en profiter pour parler d'autres nouveautés.

    Voici d'ailleurs l'interprétation de la modularité :

    Code typescript :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    // scale.ts
    export class Scale {
        weightOnEarth(mass) {}
    }
    // advancedScale.ts
    import { Scale } from "./scale" ;



    Code typescript :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    // create augmentation for Scale
    declare module "./scale" {
        // Augment Core class via interface merging
        interface Scale {
            weightOnMoon(mass); // not everyone needs moon weight
        }
    }
    Scale.prototype.advancedMethod = /* insert implementation */;
     
    // consumer.ts
    import { Scale } from "./scale";
    import "./advancedScale";
     
    let scale: Scale;
    scale.weightOnMoon(10);  // ok



    Amélioration des vérifications de type dans l'instruction for..in

    Auparavant, le type d'une variable for..in était inféré à any. Cela permettait au compilateur d'ignorer les utilisations non valides dans le corps du for..in. Maintenant, le type est implicitement string. Ce qui a pour conséquence que lorsqu'un objet avec une signature d'index numérique de type T (par exemple un tableau) est indexé par un for..in (ou similaire), la valeur produite est de type T.

    Code typescript :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    var a: MyObject[];
    for (var x in a) {   // Type of x is implicitly string
        var obj = a[x];  // Type of obj is MyObject
    }



    La version contient également :

    • l'utilisation en mode strict pour la compilation selon les directives ES6 ;
    • l'inclusion des fichiers .js dans la commande --allowJs ;
    • la possibilité d'avoir des messages d'erreurs colorés en lignes de commande ;
    • la coloration des balises JSX dans Visual Studio 2015 ;
    • etc.



    Source : Le site officiel de TypeScript


    Et vous ?

    Avez-vous testé ces nouveautés ? Qu'en pensez-vous ?


    Retrouvez nos cours et tutoriels pour apprendre TypeScript

###raw>template_hook.ano_emploi###