Le langage TypeScript
Partie 2 sur 3
4Premiers pas
TypeScript s’installe comme une bibliothèque, avec le gestionnaire de paquets npm de l’écosystème JavaScript. La commande tsc (TypeScript compiler) vérifie et traduit le code ; un fichier tsconfig.json en fixe les réglages.
npm install --save-dev typescript npx tsc --init # crée tsconfig.json npx tsc # vérifie et produit les fichiers .js
Un premier programme, dans un fichier prix.ts :
function ttc(ht: number, taux: number = 0.2): number {
return ht * (1 + taux);
}
const prix = ttc(100); // 120
console.log(prix.toFixed(2));
ttc("100"); // erreur signalée avant l'exécution
Les annotations : number indiquent le type des paramètres et du résultat. La dernière ligne est refusée par le compilateur : un texte n’est pas un nombre. En JavaScript pur, elle aurait produit un résultat absurde sans le moindre avertissement.
5Les types
5.1Types de base et inférence
Les types de base sont ceux de JavaScript : number pour tous les nombres, string pour les textes, boolean pour vrai ou faux, ainsi que null et undefined, qui représentent l’absence de valeur. Les tableaux s’écrivent number[] ou Array<number>. Il n’est presque jamais nécessaire d’annoter les variables : TypeScript déduit leur type de leur valeur, ce qu’on appelle l’inférence de types.
let ville = "Lyon"; // string, déduit let notes = [12, 15, 9]; // number[] ville = 42; // erreur : un nombre n'est pas un texte
5.2Décrire la forme des objets
Le cœur de TypeScript est la description de la forme des objets, avec le mot-clé type ou interface. Un point d’interrogation signale une propriété facultative ; readonly, une propriété qu’on ne peut pas modifier :
interface Client {
readonly id: number;
nom: string;
courriel: string;
telephone?: string; // facultatif
}
function saluer(c: Client): string {
return `Bonjour ${c.nom}`;
}
Si l’on écrit c.nmo ou c.adresse, le compilateur signale que la propriété n’existe pas, et l’éditeur propose la bonne orthographe dès la saisie (figure 1).
5.3Les unions et les types littéraux
Un type union, noté avec une barre verticale, accepte plusieurs possibilités. Combiné aux types littéraux, qui désignent une valeur précise, il permet de décrire une liste fermée de choix :
type Paiement = "carte" | "virement" | "especes"; type Identifiant = number | string; let mode: Paiement = "carte"; mode = "cheque"; // erreur : ce mode n'existe pas
Pour utiliser une valeur d’un type union, il faut d’abord déterminer de quel cas il s’agit, avec un test comme typeof, une comparaison ou l’opérateur in. TypeScript suit ces tests et affine le type dans chaque branche (en anglais narrowing) :
function afficher(id: Identifiant): string {
if (typeof id === "number") {
return id.toFixed(0); // ici, id est un number
}
return id.toUpperCase(); // ici, id est une string
}
5.4null et undefined
En mode strict, que tout projet devrait activer, TypeScript distingue les valeurs qui peuvent manquer : une variable de type string ne peut pas valoir null ; pour l’autoriser, il faut écrire string | null, et le compilateur oblige alors à vérifier l’absence de valeur avant tout usage. Deux opérateurs aident : ?. n’accède à une propriété que si l’objet existe, et ?? fournit une valeur par défaut.
function longueurTelephone(c: Client): number {
return c.telephone?.length ?? 0;
}
5.5any, unknown et never
Trois types particuliers jouent un rôle important :
anydésactive toute vérification : une valeur de ce type peut être utilisée n’importe comment. C’est une porte de sortie utile pour migrer progressivement un vieux code, mais chaqueanyest un trou dans le filet ;unknownsignifie « je ne sais pas encore ce que c’est » : on ne peut rien faire d’une telle valeur avant de l’avoir vérifiée. C’est le bon type pour les données venues de l’extérieur (coin cyber) ;neverdésigne une valeur impossible. Il sert notamment à vérifier qu’unswitchtraite tous les cas d’un type union (exercice 2).
5.6La généricité
Une fonction générique fonctionne avec n’importe quel type, tout en conservant l’information de type. Le paramètre de type s’écrit entre chevrons :
function premier<T>(liste: T[]): T | undefined {
return liste[0];
}
const n = premier([3, 1, 2]); // n est un number | undefined
const v = premier(["Lyon", "Metz"]); // v est une string | undefined
TypeScript fournit aussi des types utilitaires qui transforment d’autres types : Partial<Client> rend toutes les propriétés facultatives, Readonly<Client> les rend non modifiables, Pick<Client, "nom" | "courriel"> n’en garde que certaines. Le système de types de TypeScript est si puissant qu’il permet, en théorie, n’importe quel calcul, comme le montre une des anecdotes de cet article ; dans la pratique, on cherche au contraire à garder des types lisibles.
Pour s’exercer
Exercice 1 : trouver les erreurs
Quelles lignes le compilateur refuse-t-il, en mode strict ?
interface Produit { nom: string; prix: number; stock?: number; }
const p: Produit = { nom: "Stylo", prix: 1.5 };
const total = p.prix * 3;
const reste = p.stock - 1;
p.prx = 2;
const etiquette = p.nom.toUpperCase();
Voir la réponse
Deux lignes sont refusées. p.stock - 1 : stock est facultatif, il peut valoir undefined, et l’on ne peut pas soustraire 1 à une valeur absente ; on écrit (p.stock ?? 0) - 1. p.prx = 2 : la propriété prx n’existe pas, c’est une faute de frappe pour prix. En JavaScript pur, la première ligne donnerait NaN (« pas un nombre ») et la seconde créerait silencieusement une nouvelle propriété inutile.
Exercice 2 : n’oublier aucun cas
On ajoute "cheque" au type Paiement de la section 5.3. Comment faire en sorte que le compilateur signale toutes les fonctions qui ne traitent pas ce nouveau mode ?
Voir la réponse
On écrit les fonctions avec un switch qui se termine par une vérification d’exhaustivité :
function frais(m: Paiement): number {
switch (m) {
case "carte": return 0.5;
case "virement": return 0;
case "especes": return 0;
default:
const impossible: never = m; // erreur si un cas manque
throw new Error(`Mode inconnu : ${impossible}`);
}
}
Si tous les cas sont traités, m ne peut plus rien valoir dans la branche default, son type est never, et l’affectation est acceptée. Quand on ajoute "cheque", m peut valoir "cheque" dans cette branche, et le compilateur signale l’erreur à cet endroit précis, dans chaque fonction concernée.
6Un typage structurel
Dans des langages comme Java ou C#, deux types sont compatibles seulement si l’un est explicitement déclaré comme dérivé de l’autre. TypeScript suit une autre logique, dite structurelle : deux types sont compatibles s’ils ont la même forme, c’est-à-dire les mêmes propriétés, avec les mêmes types, quels que soient leurs noms.
interface Point { x: number; y: number; }
function distanceOrigine(p: Point): number {
return Math.sqrt(p.x ** 2 + p.y ** 2);
}
const position = { x: 3, y: 4, altitude: 120 };
distanceOrigine(position); // accepté : position a bien x et y
Cette souplesse correspond à la façon dont on écrit du JavaScript, où l’on manipule surtout des objets construits à la volée, par exemple à partir de données JSON (voir XML et JSON). Elle a une contrepartie : TypeScript ne fait pas la différence entre deux types de même forme mais de sens différent, comme un montant en euros et un montant en dollars, tous deux de type number. On contourne cette limite par des conventions de nommage ou des techniques plus avancées.
7Classes, modules et énumérations
7.1Les classes
TypeScript reprend les classes de JavaScript et leur ajoute des types et des niveaux de visibilité : public, protected et private (voir la programmation orientée objet). Une écriture abrégée permet de déclarer et d’initialiser les propriétés directement dans les paramètres du constructeur :
class Compte {
constructor(public titulaire: string, private solde: number = 0) {}
deposer(montant: number): void {
if (montant <= 0) throw new Error("Montant invalide");
this.solde += montant;
}
}
Attention : comme tous les types, le mot-clé private de TypeScript n’est vérifié qu’à la compilation. Dans le JavaScript produit, la propriété solde reste accessible à n’importe quel code. JavaScript possède depuis 2022 ses propres champs privés, notés avec un dièse, #solde, qui, eux, sont réellement inaccessibles de l’extérieur pendant l’exécution. Ni l’un ni l’autre ne protègent toutefois une donnée secrète : tout le code d’une page Web est lisible par l’utilisateur.
7.2Les modules
Chaque fichier TypeScript est un module : ce qu’il veut rendre visible, il l’exporte, et les autres fichiers l’importent. On peut importer seulement des types, avec import type, ce qui indique aux outils que cette importation disparaîtra entièrement du JavaScript produit.
// modele.ts
export interface Client { id: number; nom: string; }
export function nomComplet(c: Client): string { return c.nom; }
// app.ts
import type { Client } from "./modele";
import { nomComplet } from "./modele";
7.3Les énumérations
TypeScript propose des énumérations (enum), qui donnent des noms à une liste de valeurs. C’est l’une des rares constructions de TypeScript qui produisent du code JavaScript, au lieu de simplement disparaître. Beaucoup d’équipes leur préfèrent aujourd’hui une union de types littéraux, comme le type Paiement de la section 5.3, plus légère et compatible avec l’exécution directe des fichiers par Node.js, qui ne sait qu’effacer les types.
Pour s’exercer
Exercice 3 : compatible ou non ?
Avec l’interface Point de la section 6, lesquels de ces appels sont acceptés ? a) distanceOrigine({ x: 1, y: 2 }) ; b) distanceOrigine({ x: 1 }) ; c) distanceOrigine({ x: 1, y: "2" }) ; d) distanceOrigine({ x: 1, y: 2, z: 3 }).
Voir la réponse
a) est accepté. b) est refusé : il manque y. c) est refusé : y doit être un nombre. d) est refusé, ce qui peut surprendre après l’exemple de la section 6 : quand on écrit un objet directement dans l’appel, TypeScript signale les propriétés en trop, qui trahissent souvent une erreur. En revanche, le même objet rangé d’abord dans une variable, comme position, est accepté : la règle des propriétés en trop ne s’applique qu’aux objets écrits sur place.