+ Répondre à la discussion Actualité déjà publiée
  1. #1
    Rédacteur/Modérateur

    Avatar de yahiko
    Homme Profil pro
    Ninja
    Inscrit en
    juillet 2013
    Messages
    1 095
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ninja

    Informations forums :
    Inscription : juillet 2013
    Messages : 1 095
    Points : 5 930
    Points
    5 930
    Billets dans le blog
    39

    Par défaut TypeScript 2.1 prévu pour novembre 2016

    L'équipe chargée du développement de TypeScript indique que la version 2.1 prévue pour novembre 2016,
    et apportera entre autres le support d'une bibliothèque externe de fonctions auxiliaires

    Nom : TypeScript.png
Affichages : 2594
Taille : 1,8 Ko

    Suite à la récente mise en production de la version 2.0 de TypeScript, l'équipe en charge de son développement vient de donner de la visibilité quand à la prochaine version 2.1 qui est prévue pour ce mois de novembre. On ne sait pas cependant si cette date correspond à la version de production ou à la version beta (plus vraisemblable).

    Parmi les fonctionnalités attendues pour cette prochaine version, mentionnons :
    • Émetteur (compilation) basé sur la transformation de l'arbre syntaxique abstrait (AST)
    • Support de async/await pour ES5/ES3
    • Support d'une bibliothèque externe de fonctions auxiliaires (eg. __decorate, __metadata)
    • Meilleure inférence des types littéraux
    • Utilisation des valeurs de retour des appels à super() en tant que this
    • Analyse du flux de contrôle pour les variables implicitement any
    • Héritage des fichiers projet tsconfig.json
    • Support de "Atteindre l'implémentation" dans les services du compilateur
    • Auto-complétion pour les import et les chemins "triple-slash"
    • Support de l'opérateur d'expansion (spread) et de l'opérateur résiduel (rest) pour les propriétés d'un objet (ES8)


    source : Dépôt GitHub de TypeScript

    Que pensez-vous de cette visibilité ?
    Les nouvelles fonctionnalités proposées vous semblent-elles intéressantes ?
    Aimeriez vous d'autres fonctionnalités ?
    Tutoriels et FAQ TypeScript

  2. #2
    Membre confirmé
    Avatar de Paleo
    Homme Profil pro
    Développeur Web
    Inscrit en
    septembre 2013
    Messages
    190
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Bénin

    Informations professionnelles :
    Activité : Développeur Web

    Informations forums :
    Inscription : septembre 2013
    Messages : 190
    Points : 548
    Points
    548

    Par défaut

    Quel héritage des configs ? Les "glob" sont des sortes de jokers pour chemins d'accès aux fichiers.
    La grosse grosse modif que tout le monde attend, c'est async / await.
    https://github.com/Microsoft/TypeScript/wiki/Roadmap

  3. #3
    Membre confirmé
    Avatar de Paleo
    Homme Profil pro
    Développeur Web
    Inscrit en
    septembre 2013
    Messages
    190
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Bénin

    Informations professionnelles :
    Activité : Développeur Web

    Informations forums :
    Inscription : septembre 2013
    Messages : 190
    Points : 548
    Points
    548

  4. #4
    Chroniqueur Actualités

    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    mars 2013
    Messages
    2 591
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : mars 2013
    Messages : 2 591
    Points : 54 207
    Points
    54 207

    Par défaut L'équipe TypeScript indique que la version 2.1 est désormais disponible

    L'équipe TypeScript indique que la version 2.1 est désormais disponible
    et apporte le support de async/await pour ES5/ES3 ainsi que les extensions d'objets

    Conformément à son calendrier, Microsoft a rendu disponible la version 2.1 de TypeScript. Voici quelques nouveautés.

    Fonctions asynchrones :

    Cette version de TypeScript apporte les fonctions asynchrones de bas niveau. Les développeurs seront désormais capable d’utiliser async/await et cibler ES3/ES5 sans avoir à utiliser des outils supplémentaires.

    Les restes et les extensions d’objets :

    Ces objets font partie d’une nouvelle proposition pour ES2017 (ECMA Script 2017) visant à faciliter la copie, la fusion et la séparation partielles des objets. La fonctionnalité est déjà appelée lors de l'utilisation de bibliothèques comme Redux.

    Avec les extensions d'objet, la création d'une copie superficielle d'un objet a grandement été simplifiée :

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    let copy = { ...original };
     
     
    De même, il est possible de fusionner différents objets. Dans cet exemple, nous avons des propriétés de foo, bar et baz. 
     
     
    let merged = { ...foo, ...bar, ...baz };

    Il est même possible d’ajouter de nouvelles propriétés durant le processus :

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    let nowYoureHavingTooMuchFun = {
        hello: 100,
        ...foo,
        world: 200,
        ...bar,
    }

    Microsoft recommande de garder à l’esprit que lorsque vous utilisez les opérateurs d’extensions d’objets, toutes propriétés dans les extensions ultérieures l’emportent sur les propriétés créées précédemment. Ainsi, dans le dernier exemple, si bar avait une propriété nommée world, alors bar.world aurait été utilisé à la place de ce qui a été écrit.

    Les restes d'objet sont complémentaires aux extensions d’objets dans la mesure où ils peuvent extraire toutes les propriétés supplémentaires qui ne sont pas obtenues en déstructurant un élément :

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    let { a, b, c, ...defghijklmnopqrstuvwxyz } = alphabet;


    Les types keyof et Lookup

    Nombreuses sont les bibliothèques qui tirent profit du fait que les objets sont (pour la plupart) une collection de valeurs. Étant donné que TypeScript connaît les propriétés de chaque valeur, il existe un ensemble de chaînes de caractères connues (ou clés) que vous pouvez utiliser pour les recherches. C’est ici qu’intervient l’opérateur keyof :

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    interface Person {
        name: string;
        age: number;
        location: string;
    }
     
    let propName: keyof Person;

    Cet exemple est équivalent à celui-ci

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    let propName: "name" | "age" | "location";

    Cet opérateur keyof est en réalité une requête de type d’index ; comme une requête pour des clés sur des types d'objet, de la même façon que typeof pourrait être utilisé comme une requête pour pour des types sur des valeurs.

    Les types d’accès indexés, également appelés types lookup, ressemblent dans leur syntaxe à un accès à un élément, mais sont écrits comme des types :

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    interface Person {
        name: string;
        age: number;
        location: string;
    }
     
    let a: Person["age"];

    Cela revient à dire que "a" obtient le type de la propriété age dans Person. En d'autres termes:

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    let a: number;

    Lors de l'indexation avec une union de types littoraux, l'opérateur recherche chaque propriété et regroupe les types respectifs.

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    // Equivalent to the type 'string | number'
    let nameOrAge: Person["name" | "age"];

    Ce modèle peut être utilisé avec d'autres parties du système de type pour obtenir des recherches de type sécurisé, servant les utilisateurs de bibliothèques comme Ember.

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    function get<T, K extends keyof T>(obj: T, propertyName: K): T[K] {
        return obj[propertyName];
    }
     
    let x = { foo: 10, bar: "hello!" };
     
    let foo = get(x, "foo"); // has type 'number'
    let bar = get(x, "bar"); // has type 'string'
     
    let oops = get(x, "wargarbl"); // error!

    Les types mappés

    Disons que nous avons un type Person

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    interface Person {
        name: string;
        age: number;
        location: string;
    }

    La plupart du temps, nous voulons prendre un type existant et rendre chacune de ses propriétés entièrement facultative. Avec Person, nous pourrions écrire ce qui suit:

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    interface PartialPerson {
        name?: string;
        age?: number;
        location?: string;
    }

    Remarquez que nous devions définir un type complètement nouveau.

    De même, nous pourrions vouloir créer un type apparenté à Person où toutes les propriétés sont booléennes

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    interface BooleanifiedPerson {
        name: boolean;
        age: boolean;
        location: boolean;
    }

    Ou avec des propriétés en lecture seule

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    interface FrozenPerson {
        readonly name: string;
        readonly age: number;
        readonly location: string;
    }

    Remarquez toute cette répétition alors que, dans l’idéal, une grande partie de la même information dans chaque variante de Person aurait pu être partagée.

    Voici comment nous pouvons écrire BooleanifiedPerson avec un type mappé.

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    type BooleanifiedPerson = {
        [P in "name" | "age" | "location"]: boolean
    };

    Les types mappés sont obtenus suite à une union de types littoraux et en calculant un ensemble de propriétés pour un nouveau type d'objet. Ils sont comme des listes de compréhension en Python, mais au lieu de produire de nouveaux éléments dans une liste, ils produisent de nouvelles propriétés dans un type.

    Il est possible d’utiliser l’opérateur keyof pour réduire le code

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    type BooleanifiedPerson = {
        [P in keyof Person]: boolean
    };

    et le généraliser par la suite

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    type Booleanify<T> = {
        [P in keyof T]: boolean
    };
     
    type BooleanifiedPerson = Booleanify<Person>;

    Avec les types mappés, nous n'avons plus besoin de créer de nouvelles variantes partielles ou en lecture seule des types existants.

    Code TypeScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    // Keep types the same, but make every property optional.
    type Partial<T> = {
        [P in keyof T]?: T[P];
    };
     
    // Keep types the same, but make each property to be read-only.
    type Readonly<T> = {
        readonly [P in keyof T]: T[P];
    };

    Source : blog MSDN

Discussions similaires

  1. Réponses: 18
    Dernier message: 01/11/2009, 08h04
  2. Réponses: 10
    Dernier message: 07/08/2009, 15h42
  3. Réponses: 0
    Dernier message: 05/08/2009, 17h20
  4. Réponses: 0
    Dernier message: 16/07/2009, 11h58

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