Le langage TypeScript
Partie 3 sur 3
8De TypeScript à JavaScript
8.1La chaîne de compilation
Le compilateur de TypeScript fait deux choses distinctes : il vérifie les types et signale les erreurs, puis il produit du JavaScript en retirant simplement les annotations (figure 2). Les types n’ont aucune existence à l’exécution : c’est le principe de l’effacement des types. Le JavaScript produit est presque identique au code écrit, ce qui le rend facile à déboguer.
Dans les projets réels, la production du JavaScript est souvent confiée à des outils plus rapides, comme esbuild ou ceux intégrés aux outils de construction des sites, qui se contentent d’effacer les types sans les vérifier ; la vérification est alors lancée à part, dans l’éditeur et dans l’intégration continue. Le compilateur peut aussi produire des cartes de correspondance (en anglais source maps), qui permettent au débogueur du navigateur d’afficher le code TypeScript d’origine.
8.2Les fichiers de déclaration
Comment utiliser depuis TypeScript une bibliothèque écrite en JavaScript, qui n’a pas de types ? Grâce aux fichiers de déclaration, d’extension .d.ts, qui décrivent les types d’une bibliothèque sans contenir de code. La plupart des bibliothèques actuelles les fournissent directement ; pour les autres, le projet communautaire DefinitelyTyped en publie des milliers, sous la forme de paquets nommés @types/nom-de-la-bibliothèque. Certains projets préfèrent même rester en JavaScript, en décrivant les types dans des commentaires spéciaux, au format JSDoc, que TypeScript sait lire et vérifier.
8.3Exécuter TypeScript directement
Les environnements d’exécution récents évitent l’étape de traduction : Deno et Bun exécutent directement les fichiers .ts, et Node.js, depuis 2025, efface lui-même les annotations au chargement. Ce mode ne vérifie pas les types : il suppose que la vérification a été faite ailleurs. Les auteurs de bibliothèques continuent en revanche à publier du JavaScript accompagné de fichiers de déclaration : leurs utilisateurs n’exécutent pas forcément TypeScript, et le JavaScript publié doit fonctionner partout. Il confirme une tendance de fond : un comité de normalisation étudie même une proposition pour que JavaScript accepte nativement des annotations de type, ignorées à l’exécution.
8.4Bien régler le compilateur
Le fichier tsconfig.json fixe le niveau d’exigence du compilateur. Quelques réglages font une grande différence :
"strict": trueactive d’un coup les vérifications essentielles, dont l’interdiction desanyimplicites et le suivi des valeursnulletundefined; il devrait être activé dans tout nouveau projet ;"noUncheckedIndexedAccess": trueconsidère que l’accès à un élément de tableau, commeliste[3], peut ne rien renvoyer, ce qui oblige à traiter les dépassements ;"noImplicitReturns": truesignale les fonctions qui oublient de renvoyer une valeur dans certaines branches ;"target"indique la version de JavaScript visée, selon les navigateurs ou les serveurs à prendre en charge.
Plus le réglage est strict, plus le compilateur trouve d’erreurs, et plus le code doit être précis. Sur un projet existant, on resserre ces réglages progressivement.
9Un exemple complet : interroger une API
Le programme suivant interroge une API Web qui renvoie la liste des clients, vérifie la forme des données reçues, puis affiche les noms (voir les API). Il montre les bonnes pratiques présentées dans cet article et dans le coin cyber : la réponse est d’abord traitée comme unknown, puis validée par une fonction de garde, dont le type de retour x is Client indique à TypeScript que, si elle renvoie vrai, la valeur a bien la forme d’un client.
interface Client { id: number; nom: string; courriel: string; }
function estClient(x: unknown): x is Client {
if (typeof x !== "object" || x === null) return false;
const o = x as Record<string, unknown>;
return typeof o.id === "number"
&& typeof o.nom === "string"
&& typeof o.courriel === "string";
}
type Resultat =
| { ok: true; clients: Client[] }
| { ok: false; erreur: string };
async function chargerClients(): Promise<Resultat> {
const rep = await fetch("https://api.example.org/v1/clients");
if (!rep.ok) return { ok: false, erreur: `Code ${rep.status}` };
const donnees: unknown = await rep.json();
if (!Array.isArray(donnees) || !donnees.every(estClient)) {
return { ok: false, erreur: "Réponse mal formée" };
}
return { ok: true, clients: donnees };
}
const r = await chargerClients();
if (r.ok) {
r.clients.forEach(c => console.log(c.nom));
} else {
console.error(r.erreur);
}
Le type Resultat est une union discriminée : la propriété ok indique de quel cas il s’agit. Après le test if (r.ok), TypeScript sait que r.clients existe ; dans la branche else, seul r.erreur est accessible. Il devient impossible d’utiliser la liste des clients sans avoir vérifié que le chargement a réussi. Dans un projet réel, on remplacerait la fonction estClient, écrite à la main, par une bibliothèque de validation, qui produit à la fois la vérification et le type.
Pour s’exercer
Exercice 4 : une fonction générique
Écrivez une fonction générique dernier qui renvoie le dernier élément d’un tableau, ou undefined s’il est vide. Quel est le type de dernier([true, false]) ?
Voir la réponse
function dernier<T>(liste: T[]): T | undefined {
return liste.length > 0 ? liste[liste.length - 1] : undefined;
}
dernier([true, false]) a le type boolean | undefined : TypeScript déduit T = boolean du tableau passé en paramètre. Le | undefined rappelle à l’appelant que le tableau pouvait être vide ; il devra traiter ce cas avant d’utiliser le résultat.
Exercice 5 : la réponse de l’API
Un développeur écrit : const client = (await reponse.json()) as Client;, puis utilise client.courriel.toLowerCase(). Un jour, le serveur renvoie un objet sans courriel. Que se passe-t-il ? Le compilateur pouvait-il l’empêcher ? Que faire ?
Voir la réponse
Le programme plante à l’exécution : courriel vaut undefined, et l’on ne peut pas appeler toLowerCase sur une valeur absente. Le compilateur ne pouvait rien voir : as Client est une simple affirmation du développeur, que TypeScript croit sur parole, et les types sont effacés à l’exécution. La bonne pratique est de traiter le résultat de json() comme unknown et de le valider à l’exécution, à la main ou avec une bibliothèque de validation comme Zod ou Valibot, qui vérifie la forme des données et en déduit le type TypeScript correspondant. Une donnée invalide est alors rejetée proprement, avec un message clair, au lieu de provoquer une erreur plus loin dans le programme.
Exercice 6 : migrer un fichier JavaScript
Une équipe veut passer à TypeScript une application JavaScript de 200 fichiers sans tout arrêter. Proposez une démarche.
Voir la réponse
1) Ajouter TypeScript au projet avec l’option allowJs, qui accepte les fichiers JavaScript existants, et éventuellement checkJs, qui les vérifie déjà en partie. 2) Renommer les fichiers .js en .ts un par un, en commençant par les modules les plus simples et les plus utilisés, comme les fonctions utilitaires et les modèles de données. 3) Accepter provisoirement quelques any, en les marquant pour les retirer plus tard. 4) Activer le mode strict dès que possible, d’abord sur les nouveaux fichiers. 5) Lancer la vérification des types dans l’intégration continue, pour qu’aucune régression ne passe. La migration peut ainsi s’étaler sur des mois, sans jamais bloquer les livraisons.
Exercice 7 : une fonction de garde
Écrivez une fonction de garde estPoint(x: unknown): x is Point pour l’interface Point de la section 6, puis utilisez-la pour lire en toute sécurité le contenu d’un champ de formulaire contenant du JSON.
Voir la réponse
function estPoint(x: unknown): x is Point {
return typeof x === "object" && x !== null
&& typeof (x as Point).x === "number"
&& typeof (x as Point).y === "number";
}
let donnees: unknown;
try {
donnees = JSON.parse(champ.value);
} catch {
donnees = null; // JSON invalide
}
if (estPoint(donnees)) {
console.log(distanceOrigine(donnees)); // donnees est un Point ici
} else {
console.error("Coordonnées invalides");
}
JSON.parse renvoie une valeur de type any, qu’on range volontairement dans une variable unknown pour s’interdire de l’utiliser sans vérification. Le try traite le cas d’un texte qui n’est pas du JSON valide. Après le test estPoint, TypeScript considère donnees comme un Point, et cette fois c’est vrai, puisque la forme a été vérifiée pendant l’exécution. On pourrait ajouter un contrôle des valeurs, par exemple refuser les nombres infinis ou démesurés.
10TypeScript dans l’écosystème
TypeScript est devenu la langue commune du développement Web moderne :
- les grands cadriciels d’interface, Angular, React, Vue ou Svelte, sont écrits en TypeScript ou le prennent pleinement en charge ; avec React, on écrit des fichiers
.tsx, qui mêlent TypeScript et une syntaxe proche du HTML (voir les cadriciels Web) ; - côté serveur, TypeScript est utilisé avec Node.js, Deno ou Bun, et des cadriciels comme NestJS ou Express (voir les API) ;
- les applications de bureau construites avec les technologies du Web, comme Visual Studio Code ou de nombreuses messageries, sont souvent écrites en TypeScript ;
- les assistants de programmation par intelligence artificielle tirent parti des types, qui leur indiquent la forme exacte des données et permettent de vérifier automatiquement le code qu’ils proposent.
Ce classement mesure le nombre de personnes qui contribuent chaque mois à du code dans chaque langage sur GitHub ; d’autres indicateurs, comme les enquêtes auprès des développeurs, placent encore JavaScript ou Python devant. Tous montrent la même tendance : pour un nouveau projet Web d’une certaine taille, TypeScript est désormais le choix par défaut.
11Forces et limites
Forces
- Détection précoce de nombreuses erreurs ; code plus facile à modifier sans casser.
- Adoption progressive : un projet JavaScript peut passer à TypeScript fichier par fichier.
- Excellente aide à la saisie et à la navigation dans le code.
- Compatible avec tout l’écosystème JavaScript.
Limites
- Les types n’existent pas à l’exécution : aucune protection contre les données mal formées venues de l’extérieur.
- Le système de types peut être contourné, par
anyou par des conversions forcées avecas. - Une étape de vérification en plus, et des types parfois très complexes à lire.
- Il hérite des bizarreries de JavaScript, qu’il signale mais ne supprime pas toutes.
TypeScript ne fait pas de JavaScript un langage aussi strict que Java ou Rust : son système de types est volontairement non rigoureux sur certains points, pour rester compatible avec les usages du JavaScript existant. C’est un compromis assumé : beaucoup de garanties pour peu de contraintes.