2 pièce(s) jointe(s)
Avec Node.js v22.18.0 (LTS), les développeurs peuvent enfin exécuter directement leurs fichiers TypeScript
Node.js ajoute un support expérimental pour TypeScript. La fonctionnalité nécessite d’utiliser un package tiers tel que tsx,
car le support léger de TypeScript dans Node.js ne réalise pas de vérification de type
Le projet Node.js a récemment introduit un support expérimental pour TypeScript, activé via le drapeau --experimental-strip-types. Cette fonctionnalité permet aux développeurs d’exécuter directement des fichiers TypeScript dans Node.js en supprimant les annotations de type. Auparavant, les applications Node.js nécessitaient une étape de transpilation pour convertir le TypeScript en JavaScript standard, ce qui ajoutait de la complexité au processus de développement.
Voici quelques points clés à retenir :
- Support expérimental : Le support pour TypeScript est actuellement marqué comme expérimental. Il est activé en utilisant le drapeau --experimental-strip-types.
- Types retirés : Lorsque vous exécutez un fichier TypeScript avec ce drapeau, les types sont retirés du code, transformant ainsi le TypeScript en JavaScript.
- Limitations : Seuls les types sont supprimés, et d’autres fonctionnalités TypeScript telles que les énumérations et les espaces de noms ne sont pas prises en charge. De plus, les fichiers TypeScript dans le répertoire node_modules ne sont pas pris en charge pour décourager les auteurs de packages de publier des packages écrits en TypeScript.
- TypeScript et Node.js : TypeScript, un langage fortement typé qui se compile en JavaScript, est populaire pour les applications s’exécutant dans le navigateur ou sur des moteurs JavaScript tels que V8 (utilisé par Node.js). Les enquêtes placent généralement TypeScript parmi les dix langages de programmation les plus utilisés.
- Type-checking : Le support léger de TypeScript dans Node.js ne réalise pas de vérification de type. Pour une prise en charge complète, il est recommandé d’utiliser un package tiers tel que tsx.
Dans un monde où JavaScript règne est très populaire pour le développement côté serveur, l'introduction de TypeScript a été une aubaine pour les développeurs à la recherche d'une meilleure sécurité des types et d'outils plus performants. Ne se reposant pas sur ses lauriers, la communauté Node.js a fait des progrès significatifs dans l'intégration des capacités TypeScript dans son noyau, ce qui a conduit à l'annonce d'un support expérimental pour TypeScript dans les versions récentes de Node.js. Cela devrait changer la façon dont les développeurs abordent les applications Node.js, en promettant une meilleure maintenabilité, une facilité de débogage et des bases de code plus robustes.
Le surensemble JavaScript développé par Microsoft
TypeScript est un surensemble de JavaScript développé par Microsoft. Il ajoute un typage statique optionnel au langage, ce qui permet aux développeurs de détecter les erreurs potentielles pendant la phase de développement plutôt qu'au moment de l'exécution. Les caractéristiques de TypeScript, telles que les interfaces, les espaces de noms et l'inférence de type, en font une option attrayante pour les applications à grande échelle où un code propre et fiable est primordial. Alors que JavaScript devient de plus en plus complexe avec la programmation asynchrone et de nombreuses bibliothèques, TypeScript peut servir de filet de sécurité pour les développeurs.
TypeScript, qui, comme son nom l'indique, est un langage fortement typé, se compile en JavaScript et est populaire pour les applications qui s'exécutent soit dans le navigateur, soit sur un moteur d'exécution JavaScript tel que V8, parrainé par Google et utilisé par Node.js. Les enquêtes placent généralement TypeScript parmi les dix premiers langages de programmation, l'enquête sur les langages de programmation de Redmonk indiquant plus tôt cette année qu'il connaît une « croissance lente mais régulière, passant de la septième à la sixième place ». La nature dynamique de JavaScript peut le rendre plus sujet aux erreurs et peu sûr, alors que le compilateur TypeScript détecte plus d'erreurs de codage avant le déploiement - mais seulement si le contrôle de type est effectué, ce que le support léger de Node.js ne fait pas.
Node.js a été créé par Ryan Dahl en tant que moteur d'exécution JavaScript et publié pour la première fois en 2009. Il reste de loin le moteur d'exécution JavaScript le plus populaire, bien que Dahl lui-même ait créé un second projet appelé Deno - qui, selon lui, corrige les « erreurs de conception de Node ». Deno utilise TypeScript comme langage principal et a eu un certain impact. Tout comme bun - un autre runtime qui « traite TypeScript comme un citoyen de première classe » bien qu'il ne vérifie pas le code. Deno, en revanche, peut vérifier le typeScript mais ne le fait pas par défaut pour des raisons de performance.
L'expansion de Node.js
Node.js est devenu l'épine dorsale d'importantes applications web, fournissant un environnement d'exécution pour JavaScript en dehors du navigateur. Historiquement, Node.js a été un écosystème dominé par JavaScript, mais au fur et à mesure que les applications devenaient plus complexes, la demande de systèmes de types plus robustes est devenue évidente. La prise en charge expérimentale de TypeScript marque un tournant crucial pour l'environnement Node.js, indiquant que l'équipe Node.js s'engage à adopter des pratiques de développement modernes.
Une prise en charge expérimentale qui présente des limitations
La prise en charge expérimentale de TypeScript dans Node.js permet aux développeurs d'écrire du code TypeScript qui peut être exécuté directement sans étape de transpilation distincte. Auparavant, les applications Node.js dépendaient généralement d'un processus de compilation qui convertissait TypeScript en JavaScript, ce qui ajoutait de la complexité et de la surcharge au pipeline de développement.
Grâce à cette nouvelle fonctionnalité expérimentale, les développeurs peuvent exploiter les fonctionnalités de TypeScript tout en bénéficiant d'une intégration transparente avec Node.js. Cependant, comme pour toute fonctionnalité expérimentale, il y a des mises en garde ; elle est encore en cours de développement et peut ne pas convenir à des environnements de production. Les développeurs sont encouragés à faire part de leurs commentaires afin d'améliorer cette intégration.
Il y a des limitations. Seuls les types sont dépouillés, et d'autres fonctionnalités TypeScript telles que les enums et les espaces de noms ne sont pas prises en charge, et les paramètres du fichier de configuration TypeScript tsconfig.json sont ignorés. Les cartes de source - utilisées pour déboguer JavaScript lorsqu'il est minifié ou autrement manipulé pour le déploiement - ne sont pas générées, bien qu'en remplaçant les types en ligne par des espaces blancs, les numéros de ligne sont préservés. Les fichiers TypeScript dans le répertoire node_modules, utilisés par les dépendances, ne sont pas pris en charge, afin de « décourager les auteurs de paquets de publier des paquets écrits en TypeScript ».
Cela peut sembler timide, mais il s'agit délibérément d'un « support léger », selon la documentation. Ceux qui souhaitent un support complet sont priés d'utiliser un paquet tiers tel que tsx.
Avantages de TypeScript dans Node.js
- Sécurité des types : En utilisant TypeScript, les développeurs peuvent définir des types pour leurs variables, paramètres de fonctions et valeurs de retour. Cela permet d'éliminer les pièges courants, tels que les types non définis ou incompatibles, ce qui réduit le nombre d'erreurs d'exécution.
- Outils améliorés : Les EDI et les éditeurs modernes offrent un support supérieur pour TypeScript, y compris l'auto-complétion, la documentation en ligne et la vérification des erreurs en temps réel. La productivité des développeurs s'en trouve considérablement améliorée.
- Amélioration de la maintenabilité : L'utilisation d'interfaces et de types explicites facilite la lecture et la maintenance du code, en particulier dans les bases de code plus importantes où plusieurs développeurs travaillent simultanément.
- Refonte : Le système de types de TypeScript facilite les efforts de refactorisation en permettant de détecter les problèmes au cours du processus de développement, garantissant ainsi que les changements n'introduisent pas de nouveaux bogues.
- Soutien de la communauté : Avec la popularité croissante de TypeScript, une multitude de ressources, de bibliothèques et de supports communautaires sont désormais disponibles, permettant aux développeurs d'adopter facilement les meilleures pratiques.
Cas d'utilisation
Bien que les fonctionnalités soient encore expérimentales, les premiers utilisateurs ont déjà commencé à expérimenter TypeScript dans leurs projets Node.js. Il peut s'agir de :
- Développement d'API : Lors du développement d'API RESTful, TypeScript peut aider à garantir la cohérence des formes de données, facilitant ainsi la collaboration entre les équipes front-end et back-end.
- Microservices : Pour les organisations qui utilisent des microservices, TypeScript peut améliorer la robustesse de chaque service tout en maintenant des contrats clairs.
- Applications en temps réel : Les applications impliquant des données en temps réel, telles que les applications de chat ou les tableaux de bord en direct, peuvent bénéficier de la clarté de TypeScript dans la gestion d'architectures événementielles complexes.
Conclusion
L'introduction du support expérimental de TypeScript dans Node.js représente une évolution significative dans le paysage du développement web. En fusionnant la flexibilité de JavaScript et la rigueur de TypeScript, Node.js ouvre la voie à une nouvelle ère de développement d'applications qui privilégie la maintenance, l'évolutivité et la robustesse du code.
Alors que les développeurs adoptent cette fonctionnalité expérimentale, il est essentiel de rester prudent et de fournir un retour d'information à l'équipe Node.js. L'avenir de Node.js avec TypeScript semble prometteur, et avec l'implication continue de la communauté, nous pouvons nous attendre à une intégration plus stable et plus riche en fonctionnalités qui révolutionnera la façon dont nous construisons les applications côté serveur.
En effet, la feuille de route prévoit l'ajout de nouvelles fonctionnalités à l'avenir, et Marco Ippolito, membre du Comité de pilotage technique, a fait remarquer que la liste des fonctionnalités TypeScript nécessitant une transformation en dehors de Node.js devrait « changer à l'avenir ».
Le support intégré de TypeScript pour Node.js sera pratique, mais devra être utilisé avec d'autres outils - tels que le compilateur de TypeScript - pour obtenir le contrôle de type et d'autres fonctionnalités qui rendent TypeScript intéressant. Un autre problème relevé par les développeurs est que les nouvelles versions de TypeScript risquent d'être décalées par rapport à Node.js - en particulier si l'on reste dans les versions de support à long terme de Node.js.
Malgré les limitations, il s'agit d'une fonctionnalité clé de Node.js qui contribuera à le maintenir à jour.
Sources : feuille de route pour la prise en charge expérimentale de TypeScript, module, bun
Et vous ?
:fleche: Quelle est votre expérience avec TypeScript dans vos projets Node.js ? Avez-vous déjà utilisé TypeScript dans vos applications Node.js ? Quelles ont été vos impressions ?
:fleche: Pensez-vous que le support expérimental pour TypeScript simplifie le développement dans Node.js ? Quelle est votre opinion concernant cette nouvelle fonctionnalité ? Est-elle susceptible d'avoir un impact positif sur votre flux de travail ?
:fleche: Quelles sont les limites que vous voyez avec le support expérimental ? Évoquez d'éventuelles limitations et partagez vos préoccupations.
:fleche: Comment pensez-vous que cela affectera l’écosystème des packages Node.js ? Discutez des implications potentielles pour les packages tiers et la compatibilité.
:fleche: Quelles autres fonctionnalités aimeriez-vous voir dans Node.js pour améliorer le support de TypeScript ? Pensez à d’autres améliorations possibles.
À partir de la version 23.6.0, Node.js prend en charge TypeScript sans aucun drapeau
À partir de la version 23.6.0, Node.js prend en charge TypeScript sans aucun drapeau, en raison de sa popularité croissante, TypeScript étant la fonctionnalité la plus demandée sur Node.js.
Le moteur d'exécution JavaScript Node.js peut exécuter TypeScript (le langage dérivé de JavaScript de Microsoft avec typage statique). À partir de la version 23.6.0, Node.js prend en charge TypeScript sans aucune configuration. TypeScript a atteint des niveaux de popularité incroyables et a été la fonctionnalité la plus demandée dans toutes les dernières enquêtes Node.js.
En août 2024, Node.js a introduit une nouvelle fonctionnalité expérimentale, Type Stripping, visant à résoudre un problème de longue date dans l'écosystème Node.js : l'exécution de TypeScript sans configuration. Cette fonctionnalité permet aux développeurs d’exécuter directement des fichiers TypeScript dans Node.js en supprimant les annotations de type. Activée par défaut dans la version 23.6.0 de Node.js, cette fonctionnalité est en passe de devenir stable.
TypeScript a atteint des niveaux de popularité incroyables et a été la fonctionnalité la plus demandée dans toutes les dernières enquêtes Node.js. Pour rappel, TypeScript ajoute à JavaScript un typage statique avec des annotations de type optionnelles. Il est conçu pour le développement de grandes applications et se transpose à JavaScript. TypeScript peut être utilisé pour développer des applications JavaScript pour une exécution côté client et côté serveur, comme avec Node.js.
Node.js permet aux développeurs d'utiliser JavaScript pour écrire des outils de ligne de commande et des scripts côté serveur. La possibilité d'exécuter du code JavaScript sur le serveur est souvent utilisée pour générer un contenu de page web dynamique avant que la page ne soit envoyée au navigateur web de l'utilisateur. TypeScript sur Node.js, contrairement à d'autres alternatives telles que CoffeeScript ou Flow qui n'ont jamais connu le même succès, est devenu la pierre angulaire du développement moderne.
Bien qu'il ait été pris en charge dans Node.js pendant un certain temps par le biais de chargeurs, ceux-ci reposaient fortement sur la configuration et les bibliothèques d'utilisateurs. Cette dépendance a conduit à des incohérences entre les différents chargeurs, les rendant difficiles à utiliser de manière interchangeable. L'expérience du développeur a souffert de ces incohérences et de la configuration supplémentaire requise. L'objectif est de rendre le développement plus rapide et plus simple, en éliminant les frais généraux de configuration tout en conservant la flexibilité attendue par les développeurs.
TypeScript n'est pas seulement un langage, il s'appuie également sur une chaîne d'outils pour mettre en œuvre ses fonctionnalités. L'outil principal à cet effet est tsc, le compilateur TypeScript CLI. La vérification de type est étroitement liée à l'implémentation de tsc, car il n'y a pas de spécification formelle sur la façon dont le système de type du langage doit se comporter.
Cette absence de spécification signifie que le comportement de tsc est effectivement la définition du système de types de TypeScript. tsc ne suit pas le versionnement sémantique, de sorte que même des mises à jour mineures peuvent introduire des changements dans la vérification des types qui peuvent casser le code existant.
La transpilation, en revanche, est un processus plus stable. Elle consiste à convertir le code TypeScript en JavaScript en supprimant les types, en transformant certaines constructions syntaxiques et, éventuellement, en "rétrogradant" le JavaScript pour permettre à la syntaxe moderne de s'exécuter sur des moteurs JavaScript plus anciens.
Contrairement à la vérification des types, la transpilation est moins susceptible d'être modifiée d'une version à l'autre de . La probabilité de ruptures est encore réduite lorsque nous ne considérons que la transpilation minimale nécessaire pour rendre le code TypeScript exécutable - et que nous excluons le downleveling des nouvelles fonctionnalités JavaScript qui ne sont pas encore disponibles dans le moteur JavaScript, mais qui sont disponibles dans TypeScript.
Node.js, avant de l'activer par défaut, a introduit --experimental-strip-types. Ce mode permet d'exécuter des fichiers TypeScript en supprimant simplement les types en ligne sans effectuer de vérification de type ou toute autre transformation de code. Cette technique minimale est connue sous le nom de Type Stripping. En excluant la vérification de type et la transpilation traditionnelle, les aspects les plus instables de TypeScript, Node.js réduit le risque d'instabilité et évite en grande partie la nécessité de suivre les mises à jour mineures de TypeScript.
De plus, cette solution ne nécessite aucune configuration pour l'exécution du code. Node.js élimine le besoin de cartes de source en remplaçant la syntaxe supprimée par des espaces vides, ce qui garantit que les emplacements originaux du code et de la structure restent intacts. Il est transparent - le code qui s'exécute est le code que l'auteur a écrit, sans les types.
L'équipe Node.js commente cette annonce : "Au fur et à mesure de l'évolution de cette fonctionnalité expérimentale, l'équipe Node.js continuera à collaborer avec l'équipe TypeScript et la communauté pour affiner son comportement et réduire les frictions. Vous pouvez consulter la feuille de route pour connaître les prochaines étapes pratiques."
Sources : Support intégré TypeScript sur Node.js, GitHub, Tout ce qu'il faut savoir sur le Type Stripping de Node.js
Et vous ?
:fleche: Pensez-vous que cette annonce est crédible ou pertinente ?
:fleche: Quel est votre avis sur le sujet ?
Voir aussi :
:fleche: Le top 25 des langages de programmation les plus populaires auprès des DevOps : TypeScript a détrôné JavaScript en tant que langage préféré, Ruby est en 3è position, d'après CircleCI
:fleche: Microsoft annonce la disponibilité de la version stable de TypeScript 5.7, apportant des améliorations à la vérification des variables non initialisées ainsi qu'à la réécriture des chemins relatifs
:fleche: Node.js 20.6 est disponible avec une prise en charge des fichiers de configuration .env et l'intégration du garbage collector C++ "Oilpan"
1 pièce(s) jointe(s)
Avec Node.js v22.18.0 (LTS), les développeurs peuvent enfin exécuter directement leurs fichiers TypeScript
Node.js intègre enfin le support de TypeScript en natif : avec Node.js v22.18.0 (LTS), les développeurs peuvent enfin exécuter directement leurs fichiers TypeScript sans configuration supplémentaire
Historiquement, le mariage entre Node.js et TypeScript a toujours nécessité une étape de préparation un peu fastidieuse. On devait d'abord compiler le code TypeScript en JavaScript, puis lancer le JavaScript compilé avec Node.js. C'était comme préparer un gâteau en deux fois : d'abord la pâte, puis la cuisson, sans pouvoir sauter l'une des étapes.
Heureusement, les choses ont changé ! Les versions récentes de Node.js, y compris la version 22, peuvent désormais exécuter des fichiers TypeScript directement. C'est un gain de temps considérable, surtout pour les projets simples ou les scripts. On peut maintenant lancer un fichier .ts sans avoir à le transformer au préalable en .js, à condition que le code ne contienne que des éléments qui peuvent être simplement ignorés, comme les annotations de types.
Comment ça marche ?
Node.js gère cette exécution directe grâce à une fonctionnalité appelée "type stripping" (ou "suppression des types"). Au moment de l'exécution, Node.js examine votre code TypeScript et supprime tout ce qui concerne les types, comme les indications string ou number, les laissant se transformer en simples espaces blancs. Le code restant est du JavaScript pur, que Node.js comprend et exécute sans problème.
C'est un peu comme si vous lisiez une recette de cuisine et que vous ignoriez les commentaires sur le type d'ingrédients à utiliser (par exemple, « farine de blé », « sucre blanc »). L'essentiel de la recette (les quantités et les étapes) reste lisible et vous permet de cuisiner sans problème.
Exécuter du TypeScript sans configuration, une petite révolution pour les développeurs
Chaque nouvelle version de Node.js, la célèbre plateforme d’exécution JavaScript, apporte son lot d’améliorations. Mais la sortie de Node.js 22.18.0 LTS (Jod) marque un véritable tournant : pour la première fois, il devient possible d’exécuter directement des fichiers TypeScript sans configuration supplémentaire ni outil tiers. Une avancée technique qui peut sembler discrète, mais qui change la vie de nombreux développeurs et simplifie l’adoption de TypeScript, devenu un standard incontournable.
Qu’est-ce que Node.js, au juste ?
Pour bien comprendre la portée de cette nouveauté, faisons un petit détour. Node.js est une plateforme qui permet d’exécuter du JavaScript en dehors du navigateur. Concrètement, c’est grâce à Node.js que l’on peut utiliser JavaScript pour créer des serveurs web, des applications back-end, des outils en ligne de commande, et même des applications multiplateformes.
Depuis sa création en 2009, Node.js est devenu l’un des piliers du développement moderne. On lui doit notamment la montée en puissance du JavaScript au-delà du simple « langage du web ».
Et TypeScript, dans tout ça ?
TypeScript, créé par Microsoft en 2012, est une surcouche de JavaScript qui ajoute un système de types. Cela signifie que les développeurs peuvent préciser dans leur code à quoi sert chaque variable, fonction ou objet. Cela leur permet de détecter les erreurs potentielles pendant la phase de développement plutôt qu'au moment de l'exécution.
Les caractéristiques de TypeScript, telles que les interfaces, les espaces de noms et l'inférence de type, en font une option attrayante pour les applications à grande échelle où un code propre et fiable est primordial. Alors que JavaScript devient de plus en plus complexe avec la programmation asynchrone et de nombreuses bibliothèques, TypeScript peut servir de filet de sécurité pour les développeurs.
TypeScript, qui, comme son nom l'indique, est un langage fortement typé, se compile en JavaScript et est populaire pour les applications qui s'exécutent soit dans le navigateur, soit sur un moteur d'exécution JavaScript tel que V8, parrainé par Google et utilisé par Node.js. Les enquêtes placent généralement TypeScript parmi les dix premiers langages de programmation. Par exemple, dans l'édition de juillet 2025 de l'index PYPL qui mesure la popularité des langages en fonction de la fréquence des recherches de tutoriels pour chaque langage sur Google, TypeScript est classé à la 7ème position.
D'ailleurs, Robert Vitonsky est allé plus loin en déclarant : « refuser TypeScript est un signal que vous ne vous souciez pas de la qualité du code ».
Et d'estimer que :
Citation:
Envoyé par Robert Vitonsky
Le contrôle de la qualité du code est un processus complexe qui permet de maintenir le code à jour. Vous ne pouvez pas simplement couvrir le code avec des tests à 100% ou examiner chaque pull request et être sûr que votre code est maintenable, et quelqu'un d'autre que vous peut le découvrir dans ce désordre.
Vous ne pouvez pas vous assurer que votre code n'a pas de bogues et qu'il est parfaitement maintenable. Vous pouvez seulement augmenter les structures défensives dans votre référentiel pour rendre difficile la diffusion de mauvais code avec des bogues. Plus il y a de barrières au mauvais code, meilleure est la qualité du code.
Cela signifie que vous devez utiliser toutes les méthodes ensemble pour protéger le code dans votre référentiel : tests unitaires/e2e/intégration, revue de code, outils d'analyse de code, et maintenir une documentation claire, etc.
TypeScript est un outil d'analyse de code puissant ; il peut détecter de nombreux défauts dans le code. Un compilateur TypeScript oblige les programmeurs à s'assurer que le code est correct au niveau des types. La valeur du typage statique est sous-estimée par David et beaucoup d'autres.
La nature dynamique de JavaScript peut le rendre plus sujet aux erreurs et peu sûr, alors que le compilateur TypeScript détecte plus d'erreurs de codage avant le déploiement - mais seulement si le contrôle de type est effectué, ce que le support léger de Node.js ne fait pas.
Node.js a été créé par Ryan Dahl en tant que moteur d'exécution JavaScript et publié pour la première fois en 2009. Il reste de loin le moteur d'exécution JavaScript le plus populaire, bien que Dahl lui-même ait créé un second projet appelé Deno (qui, selon lui, corrige les « erreurs de conception de Node »). Deno utilise TypeScript comme langage principal et a eu un certain impact. Tout comme bun - un autre runtime qui « traite TypeScript comme un citoyen de première classe » bien qu'il ne vérifie pas le code. Deno, en revanche, peut vérifier le typeScript mais ne le fait pas par défaut pour des raisons de performance.
Par exemple :
Code:
1
2
3
| function greet(name: string): string {
return `Bonjour, ${name}`;
} |
Ici, le : string indique que la variable name doit obligatoirement être une chaîne de caractères. Résultat : le code est plus clair, plus robuste, et les erreurs sont détectées plus tôt.
Le revers de la médaille : TypeScript doit être compilé (traduit) en JavaScript pour fonctionner. Jusqu’à présent, on ne pouvait pas simplement lancer node fichier.ts : il fallait d’abord passer par un compilateur (tsc) ou un outil tiers (ts-node, tsx).
Ce qui change avec Node.js 22.18.0
Désormais, plus besoin d’étape intermédiaire : Node.js sait lire directement les fichiers .ts.
Le type stripping automatique
Node.js retire simplement les annotations de types (: string, : number, etc.) et transforme le code en JavaScript exécutable. C’est ce que l’on appelle le type stripping.
Par exemple :
Code:
1
2
3
| $ echo 'const foo: string = "World"; console.log(`Hello ${foo}!`);' > file.ts
$ node file.ts
Hello World! |
En un seul appel, sans configuration ni outil externe, le script TypeScript s’exécute.
Mais avec des limites
Certaines fonctionnalités avancées de TypeScript ne sont pas encore prises en charge. Par exemple :
- les enum (enum Couleur { Rouge, Vert, Bleu }),
- les namespace contenant du code,
- les paramètres d’accès dans les constructeurs (constructor(private name: string)),
- et d’autres cas spécifiques.
Pour gérer ces situations, Node.js propose une option supplémentaire : --experimental-transform-types, qui active une transformation plus complète, mais encore expérimentale.
Ce que cela change dans la pratique
Pour les développeurs débutants
C’est une excellente nouvelle ! Vous pouvez écrire un script TypeScript simple et le lancer immédiatement, sans installer de compilateur, sans apprendre de configuration complexe. Cela réduit la barrière d’entrée et encourage l’adoption de TypeScript par les nouveaux venus.
Pour les projets rapides ou les prototypes
Besoin de tester une idée en quelques minutes ? Vous pouvez écrire en TypeScript, profiter des avantages des types, et lancer directement le fichier. Cela accélère énormément les phases d’expérimentation.
Pour les grandes entreprises et projets complexes
Attention, ici la nuance est importante : Node.js ne remplace pas complètement l’écosystème existant. Les entreprises qui utilisent TypeScript à grande échelle continueront probablement d’employer des outils comme ts-node, Babel ou esbuild, car ils offrent plus de contrôle (transpilation avancée, optimisation des performances, gestion de tsconfig.json, etc.).
Et la communauté dans tout ça ?
Cette évolution a suscité beaucoup de réactions positives. Depuis longtemps, la communauté demandait un support natif de TypeScript dans Node.js, car le langage est désormais utilisé massivement : selon GitHub, plus de 40 % des projets modernes utilisent TypeScript.
Cependant, certains développeurs restent prudents :
- L’implémentation actuelle est expérimentale et pourrait évoluer.
- Elle ne remplace pas un compilateur complet.
- Le risque est que certains développeurs se lancent en pensant pouvoir tout faire directement avec Node.js, et se heurtent vite aux limites.
Une étape vers une convergence JavaScript – TypeScript ?
Cette nouveauté illustre une tendance plus large : la frontière entre JavaScript et TypeScript devient de plus en plus fine.
- JavaScript reste le langage d’exécution : tout code doit finir traduit en JavaScript pour tourner.
- TypeScript devient la norme d’écriture : de plus en plus de développeurs ne veulent plus coder sans les annotations de types.
En intégrant nativement le support minimal de TypeScript, Node.js reconnaît cette réalité et facilite la transition.
Conclusion
L’arrivée du support natif de TypeScript dans Node.js 22.18.0 est une avancée qui pouvait déjà être anticipée, notamment lorsque Node.js a ajouté un support expérimental pour TypeScript. Elle simplifie la vie des développeurs, démocratise encore plus TypeScript et ouvre la voie à un futur où la configuration sera réduite au minimum.
Néanmoins, ce n’est pas (encore) une solution miracle : pour les projets sérieux et complexes, les outils spécialisés restent indispensables. Mais pour les scripts, les prototypes ou l’apprentissage, cette nouveauté est une petite révolution qui montre à quel point JavaScript et TypeScript sont devenus indissociables.
Source : note de version Node.js v22.18.0 (LTS)
Et vous ?
:fleche: Pensez-vous que l’exécution directe de fichiers TypeScript dans Node.js est une véritable révolution ou juste un gadget pratique ?
:fleche: Est-ce que cette fonctionnalité vous incitera à utiliser davantage TypeScript dans vos projets ?
:fleche: L’approche de Node.js (qui retire simplement les types) vous semble-t-elle suffisante, ou trop limitée ?
:fleche: Dans quel type de projets voyez-vous le plus d’intérêt à lancer directement du TypeScript sans configuration (scripts, prototypes, microservices…) ?
:fleche: Pour vos projets en entreprise, garderiez-vous quand même un compilateur complet (tsc, Babel, esbuild) malgré cette nouveauté ?
:fleche: Avez-vous déjà rencontré des situations où la lourdeur de la configuration vous a découragé d’utiliser TypeScript ?
Une avancée, mais pas suffisante
Perso, sur mes projet front, j'utilise du js pur pour mes scripts la plupart du temps. TS c'est bien pour le côté applicatif, avec d'ailleurs ce petit paradoxe toujours gênant qui est que les certains dev ne comprenant pas comment fonctionne JS : ils t'écrivent leur code comme du C#
Et pour du code backend pur, le support est bien trop limité pour être utilisé. Cela dit, ça laisse entrevoir une version prochaine avec un support complet natif, et ça, ça fait plaisir.
Pour en revenir à la qualité, TS seul ne suffit pas. Je préfère largement un projet en JS pur mais avec des tests unitaires pertinents qu'un projet TS sans le moindre TU.
Je trouve par contre que c'est devenu un gage de meilleure productivité, et que cet aspect est très peu mis en avant
