0.2Installer Node.js, npm & configurer VS Code
node -v / npm -v et préparer l'éditeur.Avant de coder, il faut installer Node et configurer un environnement de travail confortable. L'installation de Node apporte deux outils indissociables : Node lui-même (l'exécutable qui lance vos scripts JavaScript) et npm (Node Package Manager, le gestionnaire de paquets installé automatiquement avec Node). Point crucial du choix de version : privilégiez la version LTS (Long Term Support). Node publie deux lignes : la version LTS (paire, ex. 20.x, 22.x), stable et maintenue longtemps — celle qu'on utilise en production et pour apprendre ; et la version Current (impaire), plus récente mais moins stable, réservée à ceux qui veulent tester les toutes dernières fonctionnalités. Le réflexe : installez la LTS, sauf raison précise de faire autrement.
Pour installer, deux approches. L'installateur officiel (téléchargé depuis nodejs.org) : simple, il installe Node + npm en quelques clics — parfait pour débuter. Ou un gestionnaire de versions comme nvm (Node Version Manager, sur macOS/Linux ; nvm-windows sur Windows) : il permet d'installer PLUSIEURS versions de Node et de basculer de l'une à l'autre facilement — très utile en pratique professionnelle (différents projets peuvent exiger différentes versions de Node). Pour commencer, l'installateur officiel suffit ; nvm devient précieux quand vous jonglez entre projets. Après installation, on vérifie que tout fonctionne dans le terminal : node --version (ou node -v) affiche la version de Node, npm --version celle de npm — si ces commandes répondent, Node est bien installé et dans le PATH. Côté éditeur, Visual Studio Code (VS Code) est le standard de fait pour Node/JavaScript : gratuit, léger, avec un excellent support JavaScript intégré, un terminal intégré, et un écosystème d'extensions (ESLint pour la qualité du code, Prettier pour le formatage automatique, etc.). Installez VS Code, ouvrez-y votre dossier de projet, et vous disposez d'un environnement complet : éditeur + terminal intégré (pour lancer node et npm sans quitter l'éditeur). Ce trio — Node (LTS) + npm + VS Code — est le poste de travail standard du développeur Node, et bien le mettre en place dès le départ (bonne version, terminal fonctionnel, éditeur configuré) vous évite des frictions et vous met dans les conditions professionnelles réelles.
Vocabulaire de la section
- Node + npm
- L'installation de Node apporte l'exécutable Node (qui lance vos scripts) ET npm (le gestionnaire de paquets), installés ensemble.
- LTS vs Current
- LTS (Long Term Support, versions paires) : stable et maintenue longtemps, à privilégier. Current (impaire) : plus récente mais moins stable, pour tester les nouveautés.
- nvm (Node Version Manager)
- Outil permettant d'installer plusieurs versions de Node et de basculer entre elles ; précieux quand des projets exigent des versions différentes.
- Terminal / PATH
- Console où l'on lance node et npm ; `node -v` et `npm -v` vérifient l'installation (si elles répondent, Node est dans le PATH).
- VS Code
- Éditeur standard pour Node/JavaScript : gratuit, support JS intégré, terminal intégré, extensions (ESLint, Prettier) pour la qualité et le formatage du code.
Node est mono-thread : comment gère-t-il des milliers d'utilisateurs à la fois ?
En pratique — Installer et configurer son poste Node
- Installez Node en version LTS (via l'installateur officiel de nodejs.org, ou nvm si vous voulez gérer plusieurs versions).
- Vérifiez dans le terminal : `node --version` et `npm --version` doivent afficher des numéros — sinon, Node n'est pas dans le PATH.
- Installez VS Code, ouvrez-y un dossier de projet et repérez le terminal intégré (pour lancer node/npm sans quitter l'éditeur).
- Ajoutez les extensions utiles (ESLint pour la qualité, Prettier pour le formatage automatique) pour un environnement professionnel.
Points clés à retenir
- Installer Node apporte Node (exécute vos scripts) ET npm (gestionnaire de paquets) ensemble ; privilégier la version LTS (stable, maintenue longtemps).
- Vérifier l'installation dans le terminal : `node -v` et `npm -v` doivent répondre (Node dans le PATH).
- nvm permet d'installer/basculer entre plusieurs versions de Node — précieux en pro (projets exigeant des versions différentes) ; l'installateur officiel suffit pour débuter.
- VS Code = éditeur standard (support JS, terminal intégré, extensions ESLint/Prettier) : le trio Node + npm + VS Code est le poste de travail du développeur Node.
Questions fréquentes
Pourquoi choisir la version LTS plutôt que la dernière version disponible ?
C'est un réflexe professionnel important qui va à l'encontre de l'intuition « le plus récent est le meilleur ». Node.js publie ses versions selon un cycle bien défini avec deux lignes distinctes, et comprendre la différence guide le bon choix. Les versions LTS (Long Term Support) portent des numéros PAIRS (18, 20, 22…). « Long Term Support » signifie qu'elles sont maintenues et corrigées pendant environ 3 ans : elles reçoivent les correctifs de sécurité et de bugs sur la durée, sans introduire de changements cassants. Ce sont les versions stables, éprouvées, fiables — pensées pour la production et pour un usage sérieux. C'est ce que la grande majorité des entreprises utilisent, car elles veulent de la stabilité et un support long, pas les toutes dernières fonctionnalités expérimentales. Les versions Current portent des numéros IMPAIRS (19, 21, 23…). Elles contiennent les fonctionnalités les plus récentes, mais sont moins stables et maintenues moins longtemps (elles évoluent vite et peuvent introduire des changements). Elles s'adressent à ceux qui veulent tester les nouveautés en avant-première, contribuer, ou expérimenter — pas à la production ni à l'apprentissage. Pourquoi choisir la LTS pour apprendre et produire : (1) Stabilité : moins de surprises, de bugs, de comportements changeants — vous vous concentrez sur l'apprentissage ou votre projet, pas sur des incompatibilités. (2) Compatibilité de l'écosystème : les bibliothèques npm sont testées et garanties compatibles avec les LTS ; une version Current toute fraîche peut avoir des paquets qui ne la supportent pas encore. (3) Support long : votre projet basé sur une LTS restera maintenu et sécurisé longtemps, sans vous forcer à migrer sans cesse. (4) Alignement avec le monde réel : en apprenant sur la LTS, vous êtes dans les conditions des entreprises et des tutoriels/documentations (qui ciblent la LTS). (5) Documentation et communauté : les ressources, réponses de forums, exemples ciblent massivement les LTS. Le seul cas où prendre Current : vous avez BESOIN d'une fonctionnalité toute récente pas encore dans la LTS, et vous acceptez l'instabilité — situation rare pour un débutant. Note sur la fin de vie : chaque version a une date de « fin de support » ; utiliser une version LTS ENCORE supportée est important (une version en fin de vie ne reçoit plus de correctifs de sécurité — risque). Vérifiez de temps en temps que votre version LTS est toujours maintenue, et migrez vers une LTS plus récente quand la vôtre approche de sa fin de vie (les migrations entre LTS sont généralement fluides). En résumé : installez la dernière LTS (la plus récente des versions paires supportées), utilisez-la pour apprendre et produire, et ne prenez Current que pour expérimenter. C'est le choix de la stabilité et de la compatibilité — le bon réflexe professionnel, exactement comme choisir une version LTS de logiciel plutôt qu'une bêta. « Le plus récent » n'est pas toujours « le meilleur » en développement : la stabilité et le support priment pour tout ce qui est sérieux.
Faut-il apprendre à utiliser le terminal, ou peut-on tout faire dans VS Code ?
Il FAUT apprendre le terminal, c'est incontournable en développement Node (et en développement en général) — mais rassurez-vous, les bases suffisent et VS Code intègre un terminal qui rend cela confortable. Voyons pourquoi et comment. Pourquoi le terminal est incontournable : (1) Lancer Node et npm : on exécute un script avec node fichier.js, on installe des paquets avec npm install, on lance des scripts avec npm run dev — tout cela se fait en ligne de commande. Il n'y a pas d'alternative « tout-clic » pour ces opérations fondamentales. (2) C'est la norme du métier : le développement back-end, le déploiement, Git, Docker, les serveurs — tout passe par le terminal. Un développeur qui ne maîtrise pas le terminal est très handicapé. (3) Puissance et rapidité : une fois à l'aise, le terminal est souvent plus rapide et précis qu'une interface graphique pour les tâches de développement. (4) Serveurs distants : quand vous déploierez (section 5-4), vous administrerez souvent des serveurs UNIQUEMENT en ligne de commande (pas d'interface graphique). La bonne nouvelle : vous n'avez PAS besoin de devenir un expert du terminal. Quelques commandes de base suffisent pour démarrer : (1) Naviguer : cd dossier (entrer dans un dossier), cd .. (remonter), ls (lister le contenu, dir sur Windows cmd), pwd (où suis-je). (2) Lancer Node/npm : node fichier.js, npm install paquet, npm run script. (3) Manipuler des fichiers/dossiers : créer, déplacer, supprimer (mais souvent on le fait dans l'éditeur). (4) Vérifier : node -v, npm -v. Avec cette poignée de commandes, vous êtes opérationnel ; le reste s'apprend au fur et à mesure des besoins. Le confort de VS Code : VS Code intègre un terminal intégré (menu Terminal → Nouveau terminal, ou raccourci). Vous avez ainsi l'éditeur et le terminal dans la MÊME fenêtre : vous éditez votre code d'un côté, vous lancez node ou npm de l'autre, sans jamais quitter l'application. Le terminal intégré s'ouvre automatiquement dans le dossier de votre projet (pratique). C'est le meilleur des deux mondes : la puissance du terminal, le confort de l'éditeur. Beaucoup d'opérations restent graphiques dans VS Code (éditer les fichiers, naviguer dans l'arborescence, utiliser Git via l'interface, déboguer) — mais lancer Node, installer des paquets, et gérer le projet passent par le terminal intégré. Conseil de progression : (1) apprenez les 5-6 commandes de base (naviguer, lancer node/npm) — c'est vite fait ; (2) utilisez le terminal intégré de VS Code pour le confort ; (3) enrichissez votre vocabulaire de commandes au fil des besoins (Git, puis déploiement). Ne fuyez pas le terminal par appréhension : c'est un outil simple une fois apprivoisé, et absolument central en développement. Le refuser vous bloquerait ; l'apprendre (même juste les bases) vous ouvre tout. Considérez-le comme faisant partie intégrante de vos compétences de développeur, au même titre que l'éditeur — les deux vont ensemble. En quelques jours de pratique, le terminal deviendra naturel et vous ne pourrez plus vous en passer.
Autres ressources
nvm pour gérer plusieurs versions.