Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

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

Le , par yahiko

23PARTAGES

7  0 
Sortie de TypeScript 1.6


L'équipe TypeScript de Microsoft vient d'annoncer la mise en production de la nouvelle version 1.6 comportant son lot de nouveautés.

La principale fonctionnalité qui est livrée avec cette version concerne le support de la syntaxe JSX développée en collaboration avec l'équipe React de Facebook.

La syntaxe a de plus été enrichie de nouveaux concepts comme ceux indiqués ci-dessous.

Les expressions de classe

Définir une classe peut dorénavant se faire à l'aide d'une expression --- à la manière des fonctions --- et peut devenir anonyme. Ceci montre d'ailleurs les similitudes entre une classe et une fonction en TypeScript, puisque la première sera transpilée en une fermeture.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
class StateHandler extends class { reset() { return true; } } {
   constructor() {
     super();
   }
}

var g = new StateHandler();
g.reset();

Gardes de type personnalisées

Le concept des unions de types présent dans les précédentes versions de TypeScript était prometteur en théorie, mais se buttait en pratique à la résolution dynamique du type, malgré la notion de garde de type qui restait assez limitée.

Dans cette nouvelle version de TypeScript, il est possible de définir ses propres garde de type à l'aide de fonctions et du mot-clé is.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
interface Animal {name: string; }
interface Cat extends Animal { meow(); }

function isCat(a: Animal): a is Cat {
  return a.name === 'kitty';
}

var x: Animal;

if(isCat(x)) {
  x.meow(); // OK, x is Cat in this block
}

Intersection de types

TypeScript continue d'enrichir son système de typage avec un nouveau venu, finalement assez prévisible, qui est l'intersection de types et qui s'utilise avec l'opérateur & sur les types.
Contrairement à ce que pourrait laisser penser la terminologie, l'intersection de types correspond plutôt à une union ou une fusion entre un type A et un type B donnant un nouveau type composite, tandis que l'union de types déjà existante correspond à un choix parmi différents types, sans créer de nouveau type.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function extend<T, U>(first: T, second: U): T & U {
  let result = <T & U> {};|
  for (let id in first) {
    result[id] = first[id];
  }

  for (let id in second) {
    if (!result.hasOwnProperty(id)) {
      result[id] = second[id];
    }
  }
  return result;
}

var x = extend({ a: "hello" }, { b: 42 });
x.a; // works
x.b; // works


Classes abstraites

Pour les inconditionnels de la programmation orientée objet, TypeScript offre désormais la possibilité de déclarer des classes abstraites et partiellement abstraites.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
abstract class A {
  foo(): number { return this.bar(); }
  abstract bar(): number;
}

var a = new A();  // error, Cannot create an instance of the abstract class 'A'

class B extends A {
  bar() { return 1; }
}

var b = new b();  // success, all abstracts are defined

Alias de type génériques

Enfin, toujours dans l'enrichissement du système de typage, la nouvelle version 1.6 bénéficie de l'extension de la syntaxe des alias de types en ajoutant la généricité.

Code : Sélectionner tout
1
2
3
type switcharoo<T, U> = (u: U, t:T)=>T;
var f: switcharoo<number, string>;
f("bob", 4);

Au rang des grands absents, on pourra regretter que les fonctions génératrices et la programmation asynchrone avec l'introduction de async/await n'aient pas été implémentées --- sauf en ciblant de l'ES6, et encore, à titre expérimental --- contrairement à ce qu'indiquait la feuille de route il y a quelques temps.

Espérons que cela ne soit que partie remise pour la prochaine version.

Source : Blog officiel de l'équipe TypeScript

Que pensez-vous de ces nouveautés ?
Souhaitiez-vous d'autres améliorations pour cette version ?

Une erreur dans cette actualité ? Signalez-le nous !