{"canonical_url":"https://engineer.company/fr/glossary/typescript/","content_markdown":"# TypeScript\n\n## Ce que c'est\n\nTypeScript est un langage de programmation de Microsoft qui ajoute des annotations de type à JavaScript,\navec un compilateur, `tsc`, qui les vérifie. On abrège son nom en TS, et ses fichiers se terminent\npar `.ts`, ou `.tsx` lorsqu'ils contiennent du balisage JSX. La syntaxe JavaScript est valide en TypeScript,\nce qui lui vaut d'être appelé un surensemble de JavaScript. Le compilateur est open source sous\nlicence Apache 2.0.\n\nLes types ne durent que le temps de la vérification. Les annotations de type ordinaires sont\neffacées lorsque TypeScript produit le JavaScript ; elles ne valident pas les données à l'exécution\net ne nécessitent pas de bibliothèque de vérification des types à l'exécution. Les annotations de\ntype ne changent pas le comportement du code JavaScript exécuté. Ce fait explique à la fois leur\nintérêt et leurs limites : le vérificateur raisonne sur les types décrits dans le code source ;\nil ne valide pas les données qui arrivent pendant l'exécution du programme.\n\nLe système de types est structurel. Deux types sont compatibles lorsque leurs structures concordent,\nquel que soit leur nom, ce qui convient à l'habitude de JavaScript de faire circuler des objets\nordinaires ; C# et Java comparent plutôt les noms déclarés. Une grande partie des types est déduite,\nsi bien que les annotations figurent surtout dans les signatures de fonction et les valeurs exportées.\nLe système renonce aussi délibérément à la sûreté des types dans quelques cas. `any` désactive la vérification d'une valeur,\net une assertion écrite avec `as` demande au compilateur de croire le programmeur sur le type.\nLes deux disparaissent du résultat produit, comme le reste des annotations.\n\nIl existe trois façons courantes de l'exécuter. `tsc` vérifie un projet et produit du JavaScript.\nLes outils d'assemblage de modules comme esbuild retirent les types sans les vérifier et confient cette\nvérification à une exécution séparée de `tsc --noEmit`. Depuis les versions v23.6.0 et v22.18.0,\nNode.js exécute directement les fichiers `.ts` en remplaçant la syntaxe des types par des espaces,\nsans vérifier les types non plus, et n'accepte que la syntaxe qui peut être effacée ainsi.\nTypeScript 7.0, annoncé en juillet 2026, est une version native du compilateur écrite en Go ;\nl'équipe annonce des compilations complètes généralement 8 à 12 fois plus rapides.\n\n## Pourquoi c'est important\n\nL'équipe doit décider si une étape de compilation et un vérificateur justifient leur coût en détectant\nles erreurs avant l'exécution du code. Dans une base de code que plusieurs personnes modifient chaque\nsemaine, c'est généralement le cas. Renommer un champ fait apparaître tous les endroits qui l'utilisent,\nl'éditeur complète et explique le code à partir des types, et la signature d'un module devient un\ncontrat que ses appelants ne peuvent pas enfreindre discrètement. En contrepartie, chaque compilation\ncomprend une vérification, le fichier de configuration propose de nombreuses options et les définitions\nde type doivent suivre l'évolution des bibliothèques qu'elles décrivent.\n\nLe niveau de rigueur est le réglage le plus important. L'option `strict` active une famille de\nvérifications, dont `strictNullChecks` et `noImplicitAny`, et le manuel présente le résultat comme\nun réglage progressif plutôt qu'un interrupteur. Depuis TypeScript 6.0, cette option est activée par\ndéfaut : un nouveau projet commence donc en mode strict ; un ancien peut encore la définir à false,\net l'activer ensuite impose de reprendre chaque fichier concerné. Deux vérifications utiles se trouvent\nen dehors de cette famille et doivent être activées séparément : `noUncheckedIndexedAccess` et\n`exactOptionalPropertyTypes`.\n\nL'effacement fixe la limite. Un programme qui lit du JSON depuis une requête réseau, un fichier,\nune file d'attente ou un formulaire n'a que la parole du programmeur concernant la structure de ces\ndonnées : les types ont disparu lorsqu'elles arrivent. Les frontières du programme exigent donc une\nvalidation à l'exécution, idéalement générée à partir de la même définition que les types, pour que\nla vérification et le type ne puissent pas diverger. TypeScript assure la cohérence interne d'un\nprogramme et laisse à du code le soin de contrôler ses frontières.\n\nLe vérificateur alimente aussi d'autres outils. Un linter comme typescript-eslint peut demander des\ninformations de type au compilateur : une règle peut alors signaler une promesse que personne n'attend\nou une valeur de type `any` qui se propage dans un module. Une équipe transforme ainsi ses conventions\nen erreurs plutôt qu'en commentaires de revue.\n\n## À quoi cela ressemble en pratique\n\nDans les projets présentés sur ce site, la fiabilité de TypeScript repose sur le code généré\net les outils plutôt que sur de simples conventions. Trois pages montrent comment.\n\nSur une plateforme, le client TypeScript du frontend n'est jamais écrit à la main.\n[Il est généré à partir de la description de l'API elle-même](/fr/portfolio/generated-the-api-contract-from-the-database-out/),\nque Huma produit à partir des types Go, eux-mêmes issus du schéma de la base de données et de ses\nfonctions. Au stade de mise en œuvre documenté, le client comptait 44 076 lignes, et 61 gestionnaires\nsimulés générés à ses côtés permettaient aux tests du frontend de s'appuyer sur le véritable\ncontrat plutôt que sur un jeu de données de test écrit à la main. Chaque maillon a son propre\ngarde-fou. Une vérification du contrat dans la CI compare ce qu'envoie le frontend à ce qu'attend\nl'API et fait échouer la compilation en cas de divergence, avec une sonde du schéma sous-jacent qui\nexamine les structures réelles. Elle couvre les champs facultatifs du corps, où l'absence d'une valeur\net null se confondent facilement, ainsi que les énumérations des paramètres de requête. Un champ qui\nchange d'un seul côté fait désormais échouer une compilation quelques minutes après la modification,\nau lieu de produire une erreur 422 dans le navigateur après la livraison de l'incohérence. En\ncontrepartie, une modification du contrat n'atteint les types du client qu'en relançant la chaîne,\net la régénération est fastidieuse.\n\nUne autre page fixe une même exigence pour six langages, dont TypeScript.\n[Chaque diagnostic signalé par ESLint est une erreur](/fr/portfolio/set-a-zero-warnings-bar-across-six-languages/) :\nil n'existe aucun niveau d'avertissement où se réfugier, et les suppressions locales de diagnostic\nsont interdites : un problème doit donc être corrigé plutôt que masqué. Les hooks de pré-commit et\nde pré-push exécutent les linters et les tests, et les limites de longueur des fonctions et des\nfichiers gardent les modules lisibles.\n\nLes linters fournis avec un langage s'arrêtent avant les règles propres à un projet :\n[quinze règles ESLint spécifiques](/fr/portfolio/built-a-268-check-guard-engine-for-the-repo/)\nmaintenaient donc les conventions TypeScript de ce dépôt au stade de mise en œuvre documenté.\nElles appartenaient à un moteur de garde-fous de 274 scripts de vérification, dont 268 enregistrés\ndans les hooks de commit, et ces garde-fous disposaient de 146 tests qui leur étaient propres : un garde-fou défaillant\nlaisse tout passer sans que personne le remarque. Une règle concerne les tests plutôt que les types :\nun commit préfixé par `fix:` doit inclure un test qui échoue sans la correction. Le temps de revue\ns'est déplacé de la mécanique vers la conception ; en contrepartie, les commits sont devenus lents.\n\n## Où les problèmes surviennent\n\nLa plupart des problèmes rencontrés avec TypeScript viennent d'une confiance accordée aux types\nau-delà de ce que le compilateur peut vérifier.\n\n**Un champ déclaré comme chaîne se révèle undefined à l'exécution.** Les données viennent de\nl'extérieur du programme et ont reçu un type au lieu d'être vérifiées. La bibliothèque de types du\nDOM déclare `res.json()` comme une promesse de `any` : le compilateur accepte donc tout ce que le\ncode fait du résultat, et une assertion rend cette confiance explicite sans la rendre sûre :\n\n```ts\nconst res = await fetch(\"/api/user\");\nconst user = (await res.json()) as User; // trusted, never checked\nuser.email.toLowerCase(); // TypeError if email is missing\n```\n\nTraitez les données externes comme `unknown`, validez-les à la frontière avec un schéma utilisé à\nl'exécution et générez le type à partir de ce schéma pour que les deux restent synchronisés. Une règle\nde lint fondée sur les types peut ensuite signaler tout `any` qui échappe à ce contrôle.\n\n**Du code contenant des erreurs de type arrive tout de même en production.** `tsc` écrit encore du\nJavaScript lorsqu'il signale des erreurs, car `noEmitOnError` vaut false par défaut, tandis que les\noutils d'assemblage de modules et Node.js retirent les types sans aucune vérification. Imposez l'exécution\nde `tsc --noEmit` dans la CI et le hook de pré-commit, et faites échouer la compilation selon son\ncode de sortie.\n\n**Un accès par indice renvoie undefined alors que le type l'excluait.** La lecture d'un élément de\ntableau ou d'une clé à travers une signature d'index est typée comme toujours présente, même au-delà\nde la fin du tableau. Activez `noUncheckedIndexedAccess`, qui ajoute `undefined` à ces lectures et\noblige le code à le traiter. Associez-lui `exactOptionalPropertyTypes`, qui distingue une propriété\nabsente d'une propriété définie à `undefined`.\n\n**Un fichier qui compile avec tsc échoue lorsque Node.js l'exécute.** Le retrait des types n'enlève\nque la syntaxe dépourvue de signification à l'exécution. Les énumérations et les espaces de noms\ncontenant des valeurs arrêtent Node.js avec `ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX`, et un type importé\nsans le mot-clé `type` est traité comme une importation de valeur qui échoue à l'exécution. Activez\n`erasableSyntaxOnly` et `verbatimModuleSyntax` pour que le compilateur signale les deux problèmes\navant Node.js, écrivez `import type` pour les types et remplacez les énumérations par des objets\nlittéraux marqués `as const`.\n\n## Pour aller plus loin\n\n- [Documentation TypeScript](https://www.typescriptlang.org/docs/) — le manuel, les pages de\n  référence et les notes de version, maintenus par l'équipe TypeScript.\n- [The Basics](https://www.typescriptlang.org/docs/handbook/2/basic-types.html) — le chapitre du\n  manuel sur la vérification statique, la génération malgré les erreurs, les types effacés et la rigueur.\n- [Référence TSConfig : strict](https://www.typescriptlang.org/tsconfig/#strict) — chaque option\n  du compilateur avec sa valeur par défaut, dont les vérifications activées par strict.\n- [Compatibilité des types](https://www.typescriptlang.org/docs/handbook/type-compatibility.html) —\n  le sous-typage structurel et les cas où le système renonce délibérément à la sûreté des types.\n- [Node.js : Modules : TypeScript](https://nodejs.org/api/typescript.html) — le retrait des types,\n  la syntaxe refusée et les réglages du compilateur recommandés par Node.js.\n- [Lint fondé sur les informations de type](https://typescript-eslint.io/getting-started/typed-linting/) —\n  comment typescript-eslint donne aux règles de lint accès au vérificateur de types.\n\n\u003chttps://engineer.company/fr/glossary/typescript/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Ce que TypeScript vérifie et efface, le niveau de rigueur à choisir, son exécution par Node.js et les limites de la protection des types.","formats":{"gemtext":"https://engineer.company/fr/glossary/typescript/index.gmi","gopher":"https://engineer.company/fr/glossary/typescript/gophermap","html":"https://engineer.company/fr/glossary/typescript/","json":"https://engineer.company/fr/glossary/typescript/index.json","markdown":"https://engineer.company/fr/glossary/typescript/index.md","pdf":"https://engineer.company/fr/glossary/typescript/index.pdf"},"kind":"page","language":"fr","title":"Qu'est-ce que TypeScript ?","url":"https://engineer.company/fr/glossary/typescript/","version":1}