IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
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

    Avatar de yahiko
    Homme Profil pro
    Développeur
    Inscrit en
    juillet 2013
    Messages
    1 317
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur

    Informations forums :
    Inscription : juillet 2013
    Messages : 1 317
    Points : 8 277
    Points
    8 277
    Billets dans le blog
    43
    Par défaut 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 :


    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

    Avatar de vermine
    Profil pro
    Inscrit en
    mars 2008
    Messages
    6 483
    Détails du profil
    Informations personnelles :
    Âge : 36
    Localisation : Belgique

    Informations forums :
    Inscription : mars 2008
    Messages : 6 483
    Points : 77 510
    Points
    77 510
    Par défaut 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

Discussions similaires

  1. Réponses: 3
    Dernier message: 03/12/2015, 11h26
  2. Récupérer la quantité de ressource disponible (RAM,CPU,HDD)
    Par telecnop dans le forum Programmation et administration système
    Réponses: 11
    Dernier message: 26/10/2005, 13h23
  3. Réponses: 3
    Dernier message: 23/01/2004, 21h02
  4. [API Windows] Polices de caractères disponibles
    Par bebeours dans le forum C++Builder
    Réponses: 3
    Dernier message: 05/11/2003, 08h28
  5. Ports disponibles pour une connection
    Par Walm dans le forum Développement
    Réponses: 7
    Dernier message: 06/10/2003, 22h10

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo