Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
Laravel

Utiliser Node.js avec Visual Studio Code (extensions, débogage, mode --watch)

Cette leçon montre comment travailler efficacement avec Node.js dans Visual Studio Code : ouvrir le dossier d'un projet, utiliser le terminal intégré, obtenir une autocomplétion complète avec @types/n...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Cette leçon montre comment travailler efficacement avec Node.js dans Visual Studio Code : ouvrir le dossier d'un projet, utiliser le terminal intégré, obtenir une autocomplétion complète avec @types/node, installer les extensions utiles (ESLint, Prettier, Error Lens, REST Client…) et partager les réglages du projet dans .vscode/settings.json. Elle présente le mode --watch, qui relance automatiquement un programme à chaque enregistrement, puis le débogueur intégré : points d'arrêt simples et conditionnels, pas à pas, variables, espion, pile d'appels, console de débogage, terminal de débogage JavaScript et fichier launch.json, avec trois activités corrigées et un quiz.
  1. Objectifs

    • Organiser un projet Node.js dans Visual Studio Code et utiliser son terminal intégré.
    • Installer et configurer les extensions utiles au développement Node.js.
    • Profiter de l'autocomplétion (IntelliSense) pour les modules de Node.js.
    • Relancer automatiquement un programme avec le mode --watch.
    • Déboguer un programme et un serveur : points d'arrêt, pas à pas, variables, console de débogage.
  2. Pourquoi Visual Studio Code ?

    • Visual Studio Code (VS Code) est un éditeur de code gratuit et multiplateforme, publié par Microsoft. C'est l'éditeur le plus utilisé par les développeurs JavaScript.
    • Pour Node.js, il réunit tout ce dont vous avez besoin au même endroit :
      • un terminal intégré pour lancer node et npm sans quitter l'éditeur ;
      • l'autocomplétion des modules de Node.js et des paquets npm ;
      • un débogueur Node.js intégré, sans extension à installer ;
      • des milliers d'extensions: vérification du code, mise en forme, test d'API…
    • Prérequis : Node.js est installé (leçons 3.1 et 3.2) et VS Code est téléchargé depuis code.visualstudio.com. Sous Windows, gardez cochée l'option « Ajouter à PATH » lors de l'installation : elle permet d'ouvrir un dossier avec la commande code ..
  3. L'espace de travail

    • Dans VS Code, on ouvre toujours le dossier du projet, et non un fichier isolé : Fichier → Ouvrir le dossier…, ou dans un terminal, depuis le dossier du projet : code .. VS Code connaît alors tous les fichiers du projet, son package.json et ses paquets.
    • Les zones de Visual Studio Code pour un projet Node.js
    • Le terminal intégré s'ouvre avec Ctrl + ù sur un clavier AZERTY (Ctrl + ` sur un clavier QWERTY), ou par le menu Terminal → Nouveau terminal. Il démarre directement dans le dossier du projet.
    • Vérifiez que Node.js est bien reconnu :
    node -v
    npm -v
    Erreur « l'exécution de scripts est désactivée sur ce système » ? Sous Windows, le terminal PowerShell peut bloquer les commandes npm. La solution est expliquée pas à pas dans la leçon Erreur exécution de script sur Visual Studio Code. Vous pouvez aussi choisir le terminal Command Prompt ou Git Bash dans la liste déroulante du terminal.
  4. Exemple 1 : préparer un projet

    • Créez un dossier cours-node, ouvrez-le dans VS Code, puis dans le terminal intégré :
    npm init -y                 # crée package.json
    npm pkg set type=module     # active import / export
    npm install -D @types/node  # autocomplétion complète des modules de Node.js
  5. Le paquet @types/node contient la description de tous les modules de Node.js. Il n'est utilisé que pendant le développement (option -D) et apporte à VS Code une autocomplétion précise : en tapant fs., l'éditeur propose readFile, writeFile… avec leurs paramètres et leur documentation.
  6. Astuce : ajoutez // @ts-check en première ligne d'un fichier JavaScript. VS Code signale alors les erreurs de type, par exemple un nombre passé là où une chaîne est attendue, sans que vous ayez besoin d'écrire du TypeScript.
  7. Les extensions utiles

    • Ouvrez la vue Extensions (Ctrl + Maj + X) et cherchez-les par leur nom. Choisissez toujours l'extension de l'éditeur indiqué, souvent la plus téléchargée.
    • ExtensionÉditeurÀ quoi elle sertQuand
      ESLintMicrosoftSignale les erreurs et les mauvaises pratiques pendant la frappetout de suite
      Prettier – Code formatterPrettierMet en forme le code automatiquement (indentation, guillemets, points-virgules)tout de suite
      Error LensAlexanderAffiche les erreurs directement au bout de la ligne concernéetout de suite
      DotENVmikesteadColore les fichiers de configuration .envchapitre 6
      REST Client ou Thunder ClientHuachao Mao / Ranga VadhineniTester une API sans quitter VS Codechapitres 7 et 10
      MongoDB for VS CodeMongoDBConsulter et interroger une base MongoDBchapitre 11
    • Inutile d'installer une extension pour Node.js lui-même : le débogueur JavaScript et Node.js est déjà intégré à VS Code.
  8. Exemple 2 : les réglages du projet

    • Les réglages propres à un projet se placent dans .vscode/settings.json. Ils s'appliquent à tous ceux qui ouvrent le projet, ce qui est pratique en équipe. Créez ce fichier :
    {
      "editor.formatOnSave": true,
      "editor.defaultFormatter": "esbenp.prettier-vscode",
      "editor.tabSize": 2,
      "files.eol": "\n",
      "terminal.integrated.defaultProfile.windows": "Command Prompt"
    }
  9. À chaque enregistrement (Ctrl + S), Prettier remet en forme le fichier. files.eol impose des fins de ligne identiques sous Windows, Linux et macOS, ce qui évite de faux changements dans Git. La dernière ligne choisit l'Invite de commandes (Command Prompt) comme terminal par défaut sous Windows, ce qui évite l'erreur PowerShell signalée plus haut ; supprimez-la si vous préférez PowerShell.
  10. Exécuter un programme et le mode --watch

    • La façon la plus simple d'exécuter un fichier reste le terminal intégré : node app.js.
    • Pendant le développement, relancer le programme à chaque modification devient vite fastidieux. L'option --watch de Node.js surveille vos fichiers et redémarre automatiquement le programme dès que vous enregistrez. Elle est stable depuis Node.js 22 et ne demande aucune installation.
    • Créez ce petit serveur dans app.js:
    // app.js : petit serveur pour tester le mode --watch et le débogage
    import http from 'node:http';
    
    let visites = 0;
    
    const serveur = http.createServer((requete, reponse) => {
      visites++;
      const message = `Visite n° ${visites} : ${requete.method} ${requete.url}`;
      console.log(message);
      reponse.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
      reponse.end(message);
    });
    
    serveur.listen(3000, () => console.log('Serveur prêt sur http://localhost:3000'));
  11. Lancez-le en mode surveillance, puis ouvrez http://localhost:3000:
  12. node --watch app.js
  13. Modifiez le texte « Visite n° » en « Passage n° » et enregistrez. Le terminal affiche :
  14. Serveur prêt sur http://localhost:3000
    Visite n° 1 : GET /
    Restarting 'app.js'
    Serveur prêt sur http://localhost:3000
    Passage n° 1 : GET /
  15. Observez que le compteur est revenu à 1 : un redémarrage efface tout ce qui était en mémoire. C'est pourquoi une vraie application enregistre ses données dans une base de données (chapitres 11 et 12).
  16. Pour ne pas retaper l'option, ajoutez un script dans package.json, puis lancez-le avec npm run dev:
  17. "scripts": {
      "start": "node app.js",
      "dev": "node --watch app.js"
    }
  18. Dans de nombreux tutoriels plus anciens, vous verrez l'outil nodemon (npm install -D nodemon), qui joue le même rôle. Il reste utile pour des réglages avancés, mais --watch suffit pour ce cours.
  19. Déboguer avec VS Code

    • Plutôt que de multiplier les console.log(), le débogueur permet de mettre le programme en pause sur une ligne, puis d'inspecter toutes les variables et d'avancer instruction par instruction.
    • Le débogueur de VS Code : point d'arrêt, barre de débogage, variables, espion, pile d'appels
    • Point d'arrêt: cliquez dans la marge, à gauche du numéro de ligne (ou F9) : un point rouge apparaît. Le programme s'arrêtera avant d'exécuter cette ligne.
    • Lancer le débogage: ouvrez le fichier, puis F5 et choisissez Node.js si VS Code le demande. (Ctrl + F5 exécute sans débogage.)
    • Une autre méthode, très pratique : le terminal de débogage JavaScript. Ouvrez la palette de commandes (Ctrl + Maj + P), tapez « JavaScript Debug Terminal », puis lancez votre commande habituelle (node app.js, npm run dev) dans ce terminal : le débogueur s'y attache automatiquement.
    • Pendant la pause :
    • ToucheActionEffet
      F5Continuerreprend jusqu'au prochain point d'arrêt
      F10Pas à pas principalexécute la ligne, sans entrer dans les fonctions appelées
      F11Pas à pas détailléentre dans la fonction appelée sur la ligne
      Maj + F11Pas à pas sortanttermine la fonction en cours et revient à l'appelant
      Ctrl + Maj + F5Redémarrerrelance le débogage depuis le début
      Maj + F5Arrêtertermine la session de débogage
    • Dans la vue Exécuter et déboguer (Ctrl + Maj + D), le panneau Variables montre les valeurs au moment de la pause, l'Espion surveille les expressions de votre choix, et la Pile d'appels indique quelles fonctions ont mené jusqu'ici. Dans la Console de débogage, vous pouvez taper une expression (tableau[i], somme * 2) pour voir sa valeur à cet instant.
    • Deux variantes utiles : le point d'arrêt conditionnel (clic droit sur le point rouge → Modifier le point d'arrêt, par exemple i === 3), qui ne s'arrête que si la condition est vraie, et le point de journalisation (logpoint), qui affiche un message dans la console sans arrêter le programme et sans modifier le code.
  20. Exemple 3 : le fichier launch.json

    • Pour garder une configuration de lancement, cliquez sur « créer un fichier launch.json » dans la vue Exécuter et déboguer, puis choisissez Node.js. VS Code crée .vscode/launch.json, que vous pouvez adapter :
    {
      "version": "0.2.0",
      "configurations": [
        {
          "type": "node",
          "request": "launch",
          "name": "Lancer app.js",
          "program": "${workspaceFolder}/app.js",
          "skipFiles": ["<node_internals>/**"]
        },
        {
          "type": "node",
          "request": "launch",
          "name": "Déboguer npm run dev",
          "runtimeExecutable": "npm",
          "runtimeArgs": ["run", "dev"],
          "console": "integratedTerminal",
          "skipFiles": ["<node_internals>/**"]
        }
      ]
    }
  21. La première configuration lance app.js. La seconde lance le script npm run dev: vous déboguez ainsi votre serveur en mode --watch. skipFiles évite d'entrer dans le code interne de Node.js pendant le pas à pas. Choisissez la configuration dans la liste déroulante de la vue, puis F5.
  22. Pour aller plus loin : node --inspect app.js ouvre une session de débogage à laquelle vous pouvez aussi vous connecter depuis Chrome, à l'adresse chrome://inspect.
  23. Raccourcis à connaître

      Raccourci (Windows / Linux)Action
      Ctrl + Maj + PPalette de commandes : accès à toutes les fonctions
      Ctrl + POuvrir rapidement un fichier par son nom
      Ctrl + ù (AZERTY)Afficher ou masquer le terminal
      Ctrl + EspaceForcer l'affichage de l'autocomplétion
      F12Aller à la définition d'une fonction ou d'une variable
      F2Renommer une variable partout dans le projet
      Maj + Alt + FMettre en forme le fichier
      Ctrl + : (AZERTY)Commenter ou décommenter les lignes sélectionnées
    • Sous macOS, remplacez Ctrl par Cmd.
  24. Activité 1 : préparer son espace de travail

    • Réalisez les étapes suivantes, puis cochez-les :
      1. créer le dossier cours-node et l'ouvrir dans VS Code avec code .;
      2. créer le package.json en mode module et installer @types/node;
      3. installer les extensions ESLint, Prettier et Error Lens ;
      4. créer .vscode/settings.json avec les réglages de l'exemple 2 ;
      5. écrire const x = { a:1,b:2 } dans un fichier, enregistrer, et constater la mise en forme automatique.
    • Voir le résultat attendu

      Après l'enregistrement, Prettier transforme la ligne en const x = { a: 1, b: 2 };. Le dossier contient package.json (avec "type": "module" et @types/node dans devDependencies), package-lock.json, node_modules/ et .vscode/settings.json. Si rien ne se passe à l'enregistrement, vérifiez que l'extension Prettier est installée et activée, et que la barre d'état n'affiche pas d'erreur de mise en forme.

  25. Activité 2 : trouver l'erreur avec le débogueur

    • Ce programme devrait afficher la moyenne de quatre notes, soit 13.25. Il affiche Moyenne : NaN.
    // moyenne.js : ce programme contient une erreur. Trouvez-la avec le débogueur.
    const notes = [12, 15, 9, 17];
    
    function calculerMoyenne(tableau) {
      let somme = 0;
      for (let i = 0; i <= tableau.length; i++) {
        somme += tableau[i];
      }
      return somme / tableau.length;
    }
    
    const moyenne = calculerMoyenne(notes);
    console.log(`Moyenne : ${moyenne}`);
  26. Sans le corriger tout de suite :
    1. placez un point d'arrêt sur la ligne somme += tableau[i];;
    2. lancez le débogage (F5) et ajoutez tableau[i] à l'Espion ;
    3. appuyez sur F5 plusieurs fois en observant i, somme et tableau[i];
    4. identifiez le tour de boucle qui pose problème, puis corrigez le programme.
  27. Voir le corrigé

    Aux quatre premiers tours, somme vaut successivement 12, 27, 36 puis 53. Au cinquième tour, i vaut 4 : tableau[4] n'existe pas et vaut undefined, et 53 + undefined donne NaN. La condition de la boucle doit être i < tableau.length et non i <= tableau.length: les indices vont de 0 à length - 1.

    for (let i = 0; i < tableau.length; i++) {
      somme += tableau[i];
    }
    // Moyenne : 13.25

    Version plus moderne, sans indice : const somme = tableau.reduce((total, note) => total + note, 0);

  28. Activité 3 : déboguer une requête sur un serveur

    • Avec le serveur app.js de cette leçon :
      1. ajoutez le script dev et la configuration « Déboguer npm run dev » de launch.json;
      2. placez un point d'arrêt sur la ligne console.log(message);, puis lancez cette configuration ;
      3. ouvrez http://localhost:3000/produits?page=2 dans le navigateur : que se passe-t-il dans le navigateur, et dans VS Code ?
      4. dans la console de débogage, affichez requete.url et requete.headers['user-agent'];
      5. remplacez le point d'arrêt par un point d'arrêt conditionnel visites === 3 et rechargez la page plusieurs fois.
    • Voir le corrigé
      1. Le navigateur reste en chargement : le serveur est en pause sur le point d'arrêt et n'a pas encore répondu. VS Code met la ligne en jaune et affiche les variables requete, reponse et message. Appuyez sur F5 : la page s'affiche.
      2. requete.url vaut '/produits?page=2'; user-agent décrit votre navigateur (par exemple 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) …').
      3. Les deux premiers chargements passent sans arrêt ; le programme ne s'arrête qu'au troisième. Attention : certains navigateurs demandent aussi /favicon.ico, ce qui compte comme une visite supplémentaire.
  29. À retenir

    • Dans VS Code, on ouvre le dossier du projet ; le terminal intégré (Ctrl + ù) sert à lancer node et npm.
    • @types/node apporte une autocomplétion complète ; ESLint, Prettier et Error Lens améliorent la qualité du code.
    • node --watch app.js (ou npm run dev) redémarre le programme à chaque enregistrement ; les données en mémoire sont alors perdues.
    • Le débogueur est intégré : point d'arrêt (F9), lancement (F5), pas à pas (F10, F11), variables, espion et console de débogage.
    • .vscode/settings.json et .vscode/launch.json conservent les réglages et les configurations de lancement du projet.
  30. Testez-vous

    • 1. Pourquoi faut-il ouvrir le dossier du projet plutôt qu'un seul fichier ?
    • 2. À quoi sert le paquet @types/node, et pourquoi l'installe-t-on avec -D?
    • 3. Que fait node --watch app.js? Pourquoi un compteur en mémoire revient-il à zéro ?
    • 4. Quelle est la différence entre F10 et F11 pendant une pause ?
    • 5. Pourquoi le navigateur reste-t-il « en chargement » quand le serveur est arrêté sur un point d'arrêt ?
    • Voir les réponses
      1. VS Code connaît alors tout le projet : fichiers, package.json, paquets installés, réglages .vscode; le terminal s'ouvre dans le bon dossier.
      2. Il décrit les modules de Node.js pour l'autocomplétion. Il ne sert qu'au développement, d'où -D (devDependencies).
      3. Il relance le programme à chaque modification enregistrée ; un redémarrage efface la mémoire du programme précédent.
      4. F10 exécute la ligne sans entrer dans les fonctions appelées ; F11 entre dans la fonction appelée.
      5. Le serveur est en pause avant d'avoir envoyé sa réponse ; il la termine quand on reprend l'exécution (F5).

Cet article vous a-t-il aidé ?