Aller au contenu
Encyclopédie informatique Édition 2026

Le langage TypeScript

Partie 3 sur 3

Niveau de lecture :

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.

prix.ts ttc(ht: number) avec des types compilateur vérifie les types puis les efface erreur signalée avant l’exécution prix.js ttc(ht) JavaScript pur navigateur Node.js Deno, Bun Les types n’existent plus à l’exécution : ils servent à trouver les erreurs avant.
Figure 2. Les types servent à la vérification, puis disparaissent : seul du JavaScript s’exécute.

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": true active d’un coup les vérifications essentielles, dont l’interdiction des any implicites et le suivi des valeurs null et undefined ; il devrait être activé dans tout nouveau projet ;
  • "noUncheckedIndexedAccess": true considère que l’accès à un élément de tableau, comme liste[3], peut ne rien renvoyer, ce qui oblige à traiter les dépassements ;
  • "noImplicitReturns": true signale 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.
CONTRIBUTEURS ACTIFS PAR MOIS SUR GITHUB, AOÛT 2025 (EN MILLIONS) TypeScript 2,64 Python 2,60 JavaScript 2,15 Source : GitHub, rapport Octoverse 2025. TypeScript passe en tête pour la première fois.
Figure 3. En 2025, TypeScript devient le langage le plus utilisé sur GitHub.

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 any ou par des conversions forcées avec as.
  • 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.

Sécurité de l’information

Le coin cyber

TypeScript rend le code plus fiable, ce qui profite à la sécurité. Mais il est souvent mal compris : ses vérifications s’arrêtent là où commencent les données des utilisateurs, et il hérite des risques de l’écosystème JavaScript. Les attaques sont décrites ici dans leur principe seulement.

C.1Les types s’arrêtent à la frontière

Les types de TypeScript décrivent ce que le programmeur pense recevoir ; ils ne vérifient rien à l’exécution. Une requête envoyée à un serveur, un fichier importé, la réponse d’une API, le contenu du stockage du navigateur peuvent avoir n’importe quelle forme, surtout si un attaquant les a fabriqués. Toute donnée qui franchit la frontière du programme doit donc être validée à l’exécution : types, longueurs, valeurs autorisées (exercice 5). Les conversions forcées avec as et les any sont à proscrire à ces endroits.

C.2La chaîne d’approvisionnement de npm

Un projet TypeScript dépend généralement de centaines de paquets npm, dont la plupart sont des dépendances de dépendances. C’est l’une des cibles favorites des attaquants : paquets piégés aux noms proches de paquets connus, y compris des imitations d’outils TypeScript, ou prise de contrôle du compte d’un auteur légitime. En septembre 2025, un ver baptisé Shai-Hulud s’est propagé tout seul dans npm : installé avec un paquet compromis, il cherchait sur la machine les jetons d’accès des développeurs, en profitait pour publier des versions piégées des autres paquets de chaque victime, et exfiltrait les secrets trouvés, comme les clés d’accès au cloud. Des centaines de paquets ont été contaminés en quelques jours. Les parades : fichier de verrouillage des versions, installation avec npm ci, désactivation des scripts d’installation quand c’est possible, authentification forte des comptes de publication, et outils d’analyse des dépendances.

C.3Les failles du Web restent possibles

TypeScript ne protège ni contre l’injection de code dans les pages (voir le XSS), ni contre l’injection SQL, ni contre les défauts de contrôle d’accès. Il ne protège pas non plus contre la pollution de prototype, une faiblesse propre à JavaScript, où une donnée malveillante, par exemple un objet JSON contenant une propriété au nom spécial, modifie le modèle commun à tous les objets du programme, avec des effets en cascade (voir les attaques des applications Web).

C.4Idée reçue

« Avec TypeScript, les données que je reçois ont forcément le bon type. » Faux. Le compilateur vérifie la cohérence du code, pas le contenu des données réelles. Une réponse d’API ou une requête d’utilisateur peut contenir n’importe quoi, et une annotation de type ne la transforme pas. Seule une validation à l’exécution le garantit.

C.5Bonnes pratiques

Développeur

  • Activer le mode strict ; traquer les any et les as injustifiés avec un outil d’analyse comme ESLint.
  • Typer en unknown toute donnée extérieure et la valider avant usage.
  • Échapper les données affichées dans les pages ; utiliser les protections des cadriciels plutôt que d’insérer du HTML brut.

Organisation

  • Verrouiller les versions des dépendances, installer avec npm ci, analyser les dépendances dans l’intégration continue.
  • Imposer l’authentification forte sur les comptes de publication npm ; publier avec preuve d’origine.
  • Limiter le nombre de dépendances et préférer les paquets maintenus et largement utilisés.

Référentiels : OWASP (Open Worldwide Application Security Project), NPM Security Cheat Sheet et Input Validation Cheat Sheet · OpenSSF (Open Source Security Foundation), npm Best Practices Guide.

Références

  1. G. Bierman, M. Abadi, M. Torgersen, « Understanding TypeScript », ECOOP, 2014.
  2. Z. Gao, C. Bird, E. T. Barr, « To Type or Not to Type: Quantifying Detectable Bugs in JavaScript », ICSE, 2017.
  3. D. Vanderkam, Effective TypeScript, 2e éd., O’Reilly, 2024.
  4. Microsoft, The TypeScript Handbook, documentation officielle.
  5. GitHub, Octoverse 2025, rapport annuel, 2025.
  6. Ecma International, ECMAScript Language Specification (ECMA-262), édition 2025.

Voir aussi

Citer cet article

« Le langage TypeScript », Encyclopédie informatique, révision du 26 octobre 2026.