TypeScript

Par  Clovis Durand · Mis à jour le

En résumé

TypeScript est un sur-ensemble de JavaScript créé par Microsoft, qui ajoute un système de types statiques au langage. En détectant les erreurs de type avant l'exécution, il rend le code plus fiable et plus facile à faire évoluer, un atout décisif pour un produit SaaS conçu pour durer.

TypeScript est un langage de programmation open source créé par Microsoft en 2012, sous la direction d’Anders Hejlsberg, le concepteur de C#. Il reprend JavaScript à l’identique et lui ajoute un système de types statiques : chaque variable, chaque paramètre de fonction et chaque propriété d’objet peut être déclaré avec le type de donnée qu’il accepte. Le compilateur vérifie ensuite que le programme respecte ces déclarations, avant même qu’une ligne ne s’exécute. Une variable déclarée comme un nombre ne peut pas recevoir du texte. Une fonction qui attend trois paramètres ne peut pas être appelée avec deux.

Longtemps vue comme une contrainte, cette discipline est devenue la norme. Depuis août 2025, TypeScript est le langage le plus utilisé sur GitHub, devant Python et JavaScript, selon le rapport Octoverse 2025. Pour un SaaS qui va vivre plusieurs années, c’est aujourd’hui le choix par défaut, côté frontend comme côté backend.

TypeScript vs JavaScript : quelle différence ?

JavaScript est un langage à typage dynamique : le type d’une variable est déterminé au moment de l’exécution et peut changer en cours de route. C’est pratique pour un script de quelques lignes, beaucoup moins pour une application de 200 000 lignes maintenue par cinq personnes. TypeScript ajoute une couche de vérification au-dessus, puis produit du JavaScript standard que le navigateur ou le serveur exécute normalement. Les types n’existent que pendant le développement.

function prixTTC(prixHT: number, tauxTVA: number): number {
  return prixHT * (1 + tauxTVA);
}

prixTTC("49", 0.2); // Erreur signalée par l'éditeur : "49" n'est pas un nombre

En JavaScript, cet appel passe sans alerte et renvoie une valeur absurde que quelqu’un découvrira sur une facture. En TypeScript, l’éditeur souligne la ligne en rouge avant même l’enregistrement du fichier.

Tout code JavaScript valide est aussi du TypeScript valide. Un projet existant peut donc migrer progressivement, fichier par fichier, sans réécriture.

CritèreJavaScriptTypeScript
TypageDynamique, vérifié à l’exécutionStatique, vérifié à l’écriture du code
Détection des erreurs de typeEn production, par un utilisateurDans l’éditeur, avant l’exécution
ExécutionDirecteCompilation vers JavaScript, ou exécution directe avec Node.js 24, Deno et Bun
AutocomplétionPartielle, par devinetteComplète, fondée sur les types

Pourquoi TypeScript s’est imposé

Moins de bugs en production

En JavaScript, accéder à une propriété qui n’existe pas, passer une valeur au mauvais format ou oublier un paramètre ne déclenche souvent aucune alerte pendant le développement. Le code fonctionne en apparence, jusqu’au cas particulier qui le fait planter. TypeScript attrape ces erreurs à la saisie, et le bug ne quitte jamais la machine du développeur.

L’effet est mesurable. En 2019, Airbnb a analysé les post-mortems de ses incidents et conclu que 38 % de ses bugs auraient été évités par TypeScript. Une étude académique plus prudente (« To Type or Not to Type », ICSE 2017) a rejoué des bugs publics de projets JavaScript et estimé qu’environ 15 % auraient été détectés par le typage. Même la fourchette basse représente un bug sur sept qui n’atteint pas le client.

Une documentation qui ne peut pas mentir

Les types décrivent ce qu’une fonction attend et ce qu’elle renvoie. Un développeur qui la lit n’a pas besoin d’ouvrir son implémentation ni de chercher une documentation qui date de deux versions. L’éditeur exploite la même information pour l’autocomplétion : tapez le nom d’un objet suivi d’un point, et la liste exacte de ses propriétés apparaît.

Contrairement à un commentaire ou à un wiki, cette documentation se met à jour avec le code. Si elle devient fausse, le projet ne compile plus.

Un refactoring sans sueur froide

Renommer une propriété, changer la structure d’un objet ou modifier le comportement d’une fonction est un exercice risqué en JavaScript : chaque changement peut casser un fichier éloigné que personne ne pense à vérifier. En TypeScript, le compilateur liste immédiatement tous les endroits touchés. Le refactoring devient une liste de tâches plutôt qu’un pari.

Cet avantage prend de la valeur avec le temps. Un SaaS de trois ans n’a plus la même équipe ni le même périmètre qu’à son lancement, et c’est précisément là que la dette technique s’accumule. Le typage rend chaque modification plus sûre et chaque impact visible.

Un contrat partagé entre le frontend et le backend

Quand l’interface et le serveur sont écrits dans le même langage, les types circulent des deux côtés. La forme d’un objet « utilisateur » ou d’une réponse d’API est définie une seule fois, et l’écran ne peut pas se tromper sur le format que le serveur lui envoie. Des outils comme tRPC ou Zod poussent la logique plus loin : le schéma de validation d’une requête sert aussi à typer la réponse, à générer la documentation de l’API et à vérifier les données qui entrent réellement dans le système. Notre guide sur les technologies à utiliser pour son SaaS en 2026 détaille cette stack unifiée.

TypeScript dans l’écosystème moderne

React, Next.js et Node.js fonctionnent avec TypeScript sans configuration particulière, et la plupart des outils de création de projet (Next.js, Astro, SvelteKit) génèrent du TypeScript par défaut. Côté serveur, des frameworks comme NestJS sont écrits en TypeScript depuis le premier jour. Les bibliothèques tierces fournissent leurs définitions de types, soit dans leur paquet, soit via le registre DefinitelyTyped, ce qui étend la protection au-delà du code de l’application.

L’enquête Stack Overflow 2025 situe l’adoption à 48,8 % des développeurs professionnels, en hausse de 5 points en un an. Le chiffre reste inférieur à celui de JavaScript, mais la progression ne s’est jamais inversée depuis dix ans.

Ce qui a changé en 2026

TypeScript 7.0 est compilé en Go. Sorti le 8 juillet 2026, il remplace le compilateur historique, écrit en JavaScript, par une réécriture native en Go annoncée en mars 2025. Les gains vont de 8 à 12 fois sur une compilation complète : le code source de VS Code se vérifie en 10,6 secondes au lieu de 125,7. Dans l’éditeur, afficher une erreur dans ce même projet prenait 17,5 secondes et prend désormais moins de 1,3 seconde. Le reproche du « compilateur lent sur un gros projet » n’a plus de fondement.

TypeScript 6.0, sorti en mars 2026, a modernisé les réglages par défaut. Le mode strict est désormais activé pour tout nouveau projet, et une série d’options héritées des années 2010 a été retirée. C’est la dernière version construite sur l’ancien compilateur, et elle sert de passerelle vers la 7.0.

Node.js exécute TypeScript sans compilation. Depuis la version 22.18 et dans toute la branche 24, Node.js retire les annotations de type à la volée et exécute le fichier directement. Deno et Bun le font depuis plus longtemps. Pour un script ou un petit serveur, l’étape de build disparaît. Seule contrainte : cette fonction ne traite que la syntaxe « effaçable », ce qui exclut les enums et les namespaces, deux fonctionnalités que la communauté délaisse au profit d’unions de chaînes littérales.

TypeScript et le code généré par IA

GitHub attribue une bonne part de la croissance de TypeScript aux assistants de code. Un modèle de langage produit du code plausible, pas du code vérifié, et le compilateur est le premier filet qui distingue les deux. Dans un projet typé, une fonction hallucinée ou une propriété qui n’existe pas sont signalées avant la revue humaine. Les types fournissent aussi au modèle un contexte structuré sur les données du projet, ce qui améliore la pertinence de ses propositions.

C’est pour cela que nous considérons TypeScript strict comme un prérequis du vibe coding sérieux. Notre article sur l’impact de l’IA sur la productivité des développeurs revient sur le danger du code IA plausible et sur le déplacement du goulot d’étranglement vers la revue.

Les concepts à connaître

Une interface ou un type décrit la forme d’un objet : ses propriétés, leur type, celles qui sont obligatoires ou optionnelles. Les types permettent en plus de composer des unions (« une chaîne ou un nombre ») et des intersections.

Les génériques rendent une fonction réutilisable avec plusieurs types tout en conservant la vérification : une fonction de tri acceptera un tableau de commandes ou un tableau de clients et renverra un résultat du même type que l’entrée.

Les unions de littéraux définissent un ensemble fini de valeurs autorisées, comme les statuts d’une commande (« en_attente », « validee », « expediee »). Elles ont largement remplacé les enums historiques, qui ne sont pas compatibles avec l’exécution directe par Node.js.

Le narrowing permet à TypeScript de préciser le type d’une variable après une vérification conditionnelle, ce qui évite de multiplier les assertions manuelles.

Le type unknown représente une valeur dont on ne sait encore rien et qu’il faut vérifier avant usage. Il remplace le type any, qui désactive purement et simplement la vérification.

Les limites de TypeScript

TypeScript vérifie les types, pas la logique. Un code parfaitement typé peut contenir un calcul faux ou un cas limite oublié. Le typage attrape les erreurs de structure, les tests automatisés attrapent les erreurs de comportement. Les deux sont nécessaires.

La courbe d’apprentissage est réelle sur les types avancés. Déclarer un type ou une interface s’apprend en quelques heures. Les types conditionnels et les inférences complexes demandent des semaines, et une équipe sans expérience peut perdre du temps à sur-ingénierer ses types.

Les types disparaissent à l’exécution. Une donnée qui arrive d’une API externe ou d’un formulaire n’est pas vérifiée par le compilateur, puisqu’il n’est plus là. Aux frontières du système, une validation à l’exécution (Zod, Valibot) reste indispensable.

Les erreurs courantes à éviter

La première est d’abuser du type any. Chaque any est un trou dans le filet : parfois nécessaire pour intégrer une bibliothèque non typée, il doit rester l’exception. La deuxième est de faire taire le compilateur avec des directives comme @ts-ignore au lieu de corriger l’erreur. Chaque erreur ignorée est un bug potentiel qui passera les contrôles.

La troisième est une configuration trop permissive. Le mode strict active toutes les vérifications ; un projet qui le désactive ne garde qu’une fraction de la protection tout en payant la complexité du typage. Depuis TypeScript 6.0, c’est le réglage par défaut, mais beaucoup de projets plus anciens tournent encore en mode permissif.

La dernière est l’inverse : typer chaque variable à la main alors que l’inférence de TypeScript déduit déjà le type dans la plupart des cas. Le code devient verbeux sans être plus sûr.

FAQ TypeScript

TypeScript rend-il une application plus lente ?

Non. Les types sont retirés à la compilation et le JavaScript produit est identique à ce qu’un développeur aurait écrit à la main. Le seul coût était le temps de compilation pendant le développement, et TypeScript 7 l’a divisé par dix.

Peut-on migrer un projet JavaScript existant vers TypeScript ?

Oui, sans arrêter le développement. Comme tout fichier JavaScript est déjà du TypeScript valide, on active le compilateur sur l’ensemble du projet en mode permissif, puis on convertit les fichiers un par un en commençant par les modules partagés. Airbnb a migré de cette façon et a publié son outil ts-migrate.

Faut-il TypeScript pour un MVP ?

Oui. Le surcoût au démarrage est nul, puisque les outils de création de projet génèrent déjà du TypeScript, et le coût d’une migration plus tard est réel. La seule exception est le prototype jetable de quelques jours, qui ne sera jamais mis en production.

Comment Polara Studio utilise TypeScript

Chez Polara Studio, TypeScript est utilisé sur tous nos projets, en mode strict, du composant React à la requête en base de données. Le backend tourne sur Node.js avec NestJS, le frontend sur Next.js, et les types des données métier sont partagés entre les deux couches : une modification de la structure d’une facture côté serveur fait échouer la compilation de l’écran qui l’affiche tant qu’il n’est pas mis à jour.

Les schémas de validation définis à l’entrée de nos API servent aussi à typer les réponses et à générer la spécification OpenAPI, ce qui empêche la documentation de dériver du code. Et comme nos équipes utilisent des assistants de code, le compilateur est devenu le premier relecteur de ce que l’IA propose, avant les tests et la revue de code.

Ce choix a un coût : quelques heures de rigueur supplémentaire au début de chaque projet. Il est remboursé dès le premier refactoring important, puis plusieurs fois par an sur un SaaS qui doit vivre cinq ans.

Prêt à transformer votre idéeen produit ?

Programmez un entretien découverte avec nos experts pour définir ensemble vos priorités et identifier la meilleure approche pour votre projet.

Discutons de votre projet