TypeScript

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
TypeScript
Logo.

Apparu en 9 février 2012
Auteur Anders Hejlsberg, ...
Développeur Microsoft
Dernière version stable 1.4 (le 16 janvier 2015)
Paradigme Multi-paradigme
Typage dynamique, faible, fort optionnel, statique optionnel
Influencé par JavaScript, C#, Java
Licence Open Web Foundation, compilateur : Apache 2.0
Site web http://www.typescriptlang.org/

TypeScript est un langage de programmation libre et open-source développé par Microsoft qui a pour but d'améliorer et de sécuriser la production de code JavaScript. C'est un sur-ensemble de JavaScript (c'est-à-dire que tout code JavaScript correct peut être utilisé avec TypeScript). Le code TypeScript est transcompilé en JavaScript, pouvant ainsi être interprété par n'importe quel navigateur web ou moteur JavaScript. Il a été cocréé par Anders Hejlsberg, principal inventeur de C# [1],[2],[3], [4],[5].

TypeScript permet un typage statique optionnel des variables et des fonctions, la création de classes et d'interfaces, l'import de modules, tout en conservant l'approche non-contraignante de JavaScript. Il supporte la spécification ECMAScript 6.

Fonctionnalités[modifier | modifier le code]

Le langage ajoute des fonctionnalités à ECMAScript 5. Les fonctionnalités proposées sont :

Typage statique[modifier | modifier le code]

Le langage permet de préciser le contenu d'une variable ou la valeur de retour d'une fonction (ou d'une méthode) :

// Création d'une variable contenant une valeur booléenne.
var maValeurBooleenne: boolean = false;

// Création d'une variable contenant une chaîne de caractère.
var maChaineDeCaractere: string = "Hello World";

// Création d'une variable contenant un nombre.
var monNombre: number = 1;

// Création d'une fonction retournant une chaîne de caractère.
function maFonction(): string {
    return "Ma valeur de retour";
}


Type générique[modifier | modifier le code]

Il est également possible de créer des types génériques. Pour une méthode :

function maFonction<T>(parametre: T) {
    // Contenu de la fonction.
}

Pour une classe :

class MaClasse<T> {
    maVariable : T;
    // Contenu de la classe.
}

// Création d'une instance de la classe "MaClasse" en définissant un type.
var maClasse = new MaClasse<string>();
maClasse.maVariable = "Hello World";

Interfaces[modifier | modifier le code]

Exemple[modifier | modifier le code]

Les interfaces sont un concept essentiel et permettent d'avoir cette notion de typage. En créant une interface, il devient alors possible de l'utiliser pour préciser le contenu d'une variable ou d'une classe :

interface MonInterface {
    // Création d'une signature de variable.
    maVariable: string;
    // Création d'une signature de méthode.
    maMethode(parametre: string): void;
}

class MaClasse implements MonInterface {
    maVariable: string;
    maMethode(parametre: string): void {
        // Contenu de la méthode.
    }
}

// Précision du type de la variable en utilisant l'interface.
var instance: MonInterface = new MaClasse();

DefinitelyTyped[modifier | modifier le code]

Une large bibliothèque d'interface, destinée à des classes (ou fonctions) qui ont été développés en JavaScript, est disponible sur un dépôt GitHub : DefinitelyTyped par borisyankov.

Classes[modifier | modifier le code]

Le langage apporte le support des classes. L'héritage y est également pris en charge :

class MaClasseDeBase {
    private _firstname;
    private _lastname;

    public constructor(firstname: string, lastname: string) {
        this._firstname = firstname;
        this._lastname = lastname;
    }

    public direBonjour(): string {
        return "Bonjour " + this._firstname + ", " + this._lastname;
    }
}

// La classe hérite de "MaClasseDeBase".
class MaClasse extends MaClasseDeBase {
    public constructor(firstname: string, lastname: string) {
        // Accède au constructeur de "MaClasseDeBase".
        super(firstname, lastname);
    }
}

// Création d'une instance de "MaClasse" et 
// appel de la méthode: "direBonjour" de la classe parente : "MaClasseDeBase".
var monInstance: MaClasse = new MaClasse("Jean", "Dupond");
monInstance.direBonjour();

Comme il est montré dans l'exemple ci-dessus, le langage autorise les trois types de visibilités, à c'est-à-dire : public, private et protected. Ce dernier est arrivé récemment, avec la version 1.3[6].

Modules[modifier | modifier le code]

La création de module (que l'on peut qualifier d'espace de nommage) est permise en utilisant le mot-clé module :

module mon.espace.de.nom {
    // Contenu du module: classe, fonction, etc.
}

Enumérations[modifier | modifier le code]

L'utilisation d'énumération dans du code TypeScript est offerte à travers le mot-clé enum. Sans la définition de valeur à une constante :

enum Couleur {Blue, Rouge, Vert};

Il est à noter que, par défaut, la première constante de l'énumération aura pour valeur, 0.

Avec la définition de valeur :

enum Couleur {Blue = 0, Rouge = 1, Vert = 2};

Il est tout à fait possible de donner la valeur "1" (ou tout au nombre) à la première constante.

Paramètres optionnels[modifier | modifier le code]

Lorsqu'on désire rendre un paramètre optionnel en TypeScript, il faut ajouter le caractère ? après le nom de la variable :

function maFonction(monParametre?: string) {
    // On teste si le paramètre "monParametre" a une valeur.
    if (monParametre) {
        return monParametre;
    } else {
        // Dans le cas contraire, une valeur par défaut est retournée.
        return "Hello World";
    }
}

// La valeur retournée sera : "Hello World" sans avoir un message d'avertissement lors de la compilation.
var resultat: string = maFonction();
// La valeur retournée sera : "Ma valeur".
var resultat: string = maFonction("Ma valeur");

Unions[modifier | modifier le code]

Les unions sont arrivées avec la version 1.4 du langage[7]. Cette fonctionnalité autorise l'ajout de multiples types pour le paramètre d'une fonction (ou d'une méthode) :

// La fonction autorise que le paramètre soit une chaîne de caractère ou un tableau de chaîne de caractère.
function maFonction(monParametre: string|string[]): void {
    if (typeof monParametre === "string") {
        // Traitement de ma chaîne de caractère.
    } else {
        // Traitement de mon tableau.
    }
}

Alias[modifier | modifier le code]

En plus des unions, la version 1.4 apporte la possibilité de créer des alias :

// Création d'un alias basé sur le type "number".
type MonAlias = number;
// Utilisation de l'alias ci-dessus.
var monNombre: MonAlias = 1;

Outils de développement[modifier | modifier le code]

Compilateur[modifier | modifier le code]

Pour effectuer la transformation de code TypeScript en code JavaScript, un compilateur y est nécessaire. Pour cela, il faut utiliser le compilateur, nommé tsc. Il peut être installé depuis le gestionnaire de package npm.

Environnements de développement[modifier | modifier le code]

Le compilateur peut être associé à divers environnements tel que :

Voir aussi[modifier | modifier le code]

Liens externes[modifier | modifier le code]

Références[modifier | modifier le code]