Le langage TypeScript vient d'arriver dans sa version 1.8. TypeScript est un langage proposé par Microsoft comme un sur-ensemble à JavaScript. Cette mouture vient avec des apports très intéressants

TypeScript veut rendre la programmation plus sûre qu'elle ne l'est avec JavaScript. TypeScript, langage compilé, apporte notamment la vérification et l'inférence de types. Il apporte les interfaces, en ce qui concerne la programmation objet.  Le compilateur compile du code TypeScript et génère du code JavaScript. TypeScript est un langage qui doit faciliter les grands projets.

Compilation mixte

Avec cette nouvelle version, le compilateur supporte la compilation mixte : en plus du code TypeScript en entrée, il accepte du JavaScript. TypeScript se renie-t-il pour autant ? Non. Dans le cadre d'un grand projet, il peut être nécessaire de reprendre beaucoup de code JavaScript. Si une partie de ce code peut être convertie avec profit en TypeScript, il se peut non moins que l'on ne gagne rien à porter du code JavaScript qui fonctionne convenablement.

Dans une telle situation, le nouveau commutateur --allowJS du compilateur permet d'accepter du code JavaScript. Le compilateur vérifie la syntaxe de ce code et combine la sortie avec la sortie du code TypeScript.

Extensions de module

Au départ, un module TypeScript devait être définitif. Il est désormais possible d'étendre un module existant.  Microsoft donne cet exemple :

// scale.ts
export class Scale {
    weightOnEarth(mass) {}
}

// advancedScale.ts
import { Scale } from "./scale" ;

// 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

Plus de sûreté dans le code

Deux apports intéressants en ce qui concerne la sûreté du code. D'abord le compilateur signalera une erreur quand il rentrera du code inaccessible. Ensuite, il vous aidera à éliminer de votre code les retours implicites malencontreux. En JavaScript, une fonction sans instruction return retourne implicitement undefined. Ce qui peut être souhaité, mais ce qui est souvent une cause d'erreur. Avec le nouveau commutateur --noImplicitReturns une erreur sera retournée en cas de retour implicite.

function isPizza(food) {   // Error: Not all code paths return a value.
    if (food === "pizza") {
        return true;
    }
    else if (food === "pie") {
        return true;
    }
    // implicitly returns `undefined`
}

TypeScript 1.8 est sur GitHub