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

Démarrer avec Node.js : le REPL et le premier script

Cette leçon fait faire les premiers pas avec Node.js : la console interactive REPL et ses commandes, l'exécution d'un script avec node, les options -e et -p, la lecture des arguments avec process.argv...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Cette leçon fait faire les premiers pas avec Node.js : la console interactive REPL et ses commandes, l'exécution d'un script avec node, les options -e et -p, la lecture des arguments avec process.argv, une question posée à l'utilisateur avec readline et les méthodes utiles de l'objet console. Elle construit ensuite un premier serveur web avec le module http, expliqué ligne par ligne (requête, réponse, code de statut, en-têtes, port), et compare les syntaxes import et require, avec trois activités corrigées et un quiz.
  1. Objectifs

    • Utiliser la console interactive de Node.js : le REPL.
    • Écrire et exécuter un premier script, lui passer des arguments et lui faire poser une question.
    • Utiliser les méthodes utiles de l'objet console.
    • Créer un premier serveur web et comprendre chaque ligne de son code.
    • Reconnaître les deux syntaxes de modules : require et import.
  2. Présentation

    • Node.js a été créé en 2009 par Ryan Dahl, en réponse aux problèmes de concurrence des serveurs web : les serveurs de l'époque supportaient mal de nombreuses connexions simultanées.
    • Google venait de publier V8, le moteur JavaScript de Chrome, très optimisé. Ryan Dahl a construit Node.js au-dessus de V8 : le même langage que dans le navigateur, mais côté serveur.
    • Comme Node.js utilise JavaScript, les développeurs passent facilement du code du navigateur au code du serveur, et peuvent même réutiliser du code entre les deux.
    • Node.js s'installe et se configure facilement : en quelques minutes, vous pouvez avoir un serveur web opérationnel, comme vous allez le voir.
    • Il existe deux façons d'exécuter du JavaScript avec Node.js : ligne par ligne dans le REPL, pour essayer, ou à partir d'un fichier, pour écrire un vrai programme.
  3. Le REPL : essayer du code ligne par ligne

    • Tapez node dans un terminal, sans nom de fichier : vous entrez dans le REPL (Read, Eval, Print, Loop). Node.js lit chaque ligne, l'exécute, affiche le résultat, puis attend la ligne suivante.
    • Le REPL de Node.js : lire, évaluer, afficher, recommencer
    • Quelques possibilités du REPL :
      • _ (tiret bas) contient le dernier résultat: après 6 * 7, _ + 8 donne 50 ;
      • la touche Tab complète les noms : tapez Math. puis Tab deux fois pour voir toutes les fonctions de Math;
      • les flèches ↑ et ↓ rappellent les lignes déjà tapées ;
      • une instruction incomplète (une fonction, un if) passe à la ligne suivante avec ... jusqu'à ce qu'elle soit terminée.
    • Les commandes du REPL commencent par un point :
    • CommandeRôle
      .helpAfficher la liste des commandes
      .editorMode éditeur : taper plusieurs lignes, puis Ctrl + D pour les exécuter
      .breakAbandonner une instruction sur plusieurs lignes mal partie
      .save fichier.jsEnregistrer dans un fichier tout ce qui a été tapé
      .load fichier.jsCharger et exécuter un fichier dans la session
      .exitQuitter le REPL (ou Ctrl + C deux fois)
    • Pour une seule instruction, inutile d'ouvrir le REPL : node -e exécute du code, et node -p l'exécute et affiche son résultat.
    node -e "console.log(2 + 3)"
    5
    node -p "Math.max(4, 9, 2)"
    9
  4. Exemple 1 : un premier script

    • Créez un dossier premiers-pas, ouvrez-le dans Visual Studio Code, puis créez un fichier package.json qui contient seulement { "type": "module" }. Il indique que vos fichiers utilisent la syntaxe moderne import (voir plus bas).
    • Créez le fichier bonjour.js:
    // bonjour.js : mon premier script Node.js
    const prenom = 'Sara';
    const heure = new Date().getHours();
    const salutation = heure < 18 ? 'Bonjour' : 'Bonsoir';
    
    console.log(`${salutation} ${prenom} !`);
    console.log(`Ce script est exécuté par Node.js ${process.version}.`);
  5. Exécutez-le dans le terminal, avec node suivi du nom du fichier (l'extension .js est facultative) :
  6. node bonjour.js
    Bonjour Sara !
    Ce script est exécuté par Node.js v24.22.1.
  7. Le script s'exécute de haut en bas, puis Node.js s'arrête et rend la main au terminal.
  8. Exemple 2 : passer des arguments à un script

    • Les mots tapés après le nom du fichier sont transmis au script dans le tableau process.argv:
    // arguments.js : lire les valeurs passées après le nom du fichier
    console.log(process.argv);
    
    const [, , prenom = 'inconnu', age] = process.argv;
    console.log(`Prénom : ${prenom}`);
    if (age) console.log(`Dans 10 ans, vous aurez ${Number(age) + 10} ans.`);
    node arguments.js Sara 25
    [
      'C:\\Program Files\\nodejs\\node.exe',
      'C:\\premiers-pas\\arguments.js',
      'Sara',
      '25'
    ]
    Prénom : Sara
    Dans 10 ans, vous aurez 35 ans.
  9. Les deux premières cases contiennent le chemin de Node.js et celui du script ; vos arguments commencent à l'indice 2. Ils arrivent toujours sous forme de chaînes: '25' doit être converti avec Number() avant un calcul.
  10. La déstructuration const [, , prenom = 'inconnu', age] ignore les deux premières cases et donne une valeur par défaut au prénom.
  11. Exemple 3 : poser une question à l'utilisateur

    • Il n'y a pas de prompt() dans Node.js. Le module readline lit ce que l'utilisateur tape dans le terminal :
    // convertir.js : poser une question à l'utilisateur et attendre sa réponse
    import readline from 'node:readline/promises';
    import { stdin as input, stdout as output } from 'node:process';
    
    const rl = readline.createInterface({ input, output });
    
    const reponse = await rl.question('Température en degrés Celsius : ');
    const celsius = Number(reponse);
    
    if (Number.isNaN(celsius)) {
      console.error('Ce n\'est pas un nombre.');
      process.exitCode = 1;
    } else {
      const fahrenheit = celsius * 9 / 5 + 32;
      console.log(`${celsius} °C = ${fahrenheit.toFixed(1)} °F`);
    }
    rl.close();
    node convertir.js
    Température en degrés Celsius : 21
    21 °C = 69.8 °F
  12. await rl.question(…) met le programme en attente de la réponse, sans bloquer Node.js (programmation asynchrone, chapitre 5). process.exitCode = 1 signale au terminal que le programme s'est terminé en erreur ; 0 signifie « tout s'est bien passé ».
  13. L'objet console

    • console.log() n'est pas la seule méthode utile :
    // console.js : les méthodes utiles de l'objet console
    const stagiaires = [
      { nom: 'Sara', note: 15 },
      { nom: 'Ali', note: 12 },
      { nom: 'Mouna', note: 17 },
    ];
    
    console.log('Message normal');
    console.error('Message d\'erreur (sortie d\'erreur)');
    console.table(stagiaires);
    
    console.time('calcul');
    const moyenne = stagiaires.reduce((s, x) => s + x.note, 0) / stagiaires.length;
    console.timeEnd('calcul');
    console.log(`Moyenne : ${moyenne.toFixed(2)}`);
    Message normal
    Message d'erreur (sortie d'erreur)
    ┌─────────┬─────────┬──────┐
    │ (index) │ nom     │ note │
    ├─────────┼─────────┼──────┤
    │ 0       │ 'Sara'  │ 15   │
    │ 1       │ 'Ali'   │ 12   │
    │ 2       │ 'Mouna' │ 17   │
    └─────────┴─────────┴──────┘
    calcul: 0.017ms
    Moyenne : 14.67
  14. console.error() écrit sur la sortie d'erreur, séparée de la sortie normale : on peut ainsi enregistrer les erreurs dans un fichier à part. console.table() affiche un tableau d'objets ; console.time() et console.timeEnd() mesurent une durée.
  15. Notre premier serveur web

    • Une fois Node.js installé, construisons notre premier serveur web. Créez un fichier app.js:
    // app.js : premier serveur web
    import http from 'node:http';
    
    const hote = '127.0.0.1';
    const port = 3000;
    
    const serveur = http.createServer((req, res) => {
      res.statusCode = 200;
      res.setHeader('Content-Type', 'text/plain; charset=utf-8');
      res.end('Hello World');
    });
    
    serveur.listen(port, hote, () => {
      console.log(`Serveur démarré sur http://${hote}:${port}/`);
    });
  16. Lancez le serveur avec node app.js. Le terminal affiche « Serveur démarré sur http://127.0.0.1:3000/ » et ne rend pas la main: le serveur attend des requêtes. Ouvrez http://localhost:3000 dans votre navigateur : la page affiche « Hello World ». Pour arrêter le serveur, revenez dans le terminal et appuyez sur Ctrl + C.
  17. Cycle requête et réponse du premier serveur Node.js
  18. Explication détaillée

    • Passons à l'explication de ce programme, ligne par ligne.
    • import http from 'node:http';
    • Node.js est livré avec de nombreux modules de base, parmi lesquels le module http, qui permet de créer un serveur web. Cette ligne charge le module et donne accès à ses fonctions par l'objet http. Le préfixe node: indique clairement qu'il s'agit d'un module intégré à Node.js, et non d'un paquet npm.
    • const hote = '127.0.0.1'; et const port = 3000;
    • 127.0.0.1 est l'adresse de votre propre ordinateur (on l'appelle aussi localhost) : le serveur n'est accessible que depuis votre machine. Le port est un numéro qui distingue les différents services d'une même machine ; 3000 est un choix courant en développement. Deux programmes ne peuvent pas écouter le même port en même temps.
    • http.createServer((req, res) => { … })
    • La méthode createServer crée un serveur web. La fonction qu'on lui passe sera appelée à chaque requête reçue. Elle reçoit deux paramètres, que l'on nomme comme on veut (souvent req et res) :
      • la requête (req): les détails de ce que le navigateur demande (adresse, méthode GET ou POST, en-têtes HTTP…). Nous ne l'utilisons pas encore ;
      • la réponse (res): l'objet qui permet de construire la réponse.
    • res.statusCode = 200;
    • Le code de statut 200 signifie « OK ». D'autres codes existent : 404 (introuvable), 500 (erreur du serveur)…
    • res.setHeader('Content-Type', 'text/plain; charset=utf-8');
    • L'en-tête Content-Type indique au navigateur le type de contenu envoyé : ici du texte brut, encodé en UTF-8 pour que les accents s'affichent correctement. On pourrait envoyer text/html ou application/json, tant qu'il s'agit d'un type MIME standard.
    • res.end('Hello World');
    • Envoie le texte et termine la réponse. Sans res.end(), le navigateur attendrait indéfiniment.
    • serveur.listen(port, hote, () => { … });
    • La méthode listen lance l'écoute sur le port et l'adresse indiqués : c'est elle qui démarre réellement le serveur. La fonction passée en dernier paramètre est appelée une fois le serveur prêt ; console.log y affiche un message dans le terminal.
  19. require ou import ?

    • Dans de nombreux tutoriels, vous trouverez ce même serveur écrit avec require. C'est l'ancienne syntaxe de modules de Node.js, appelée CommonJS:
    // app.cjs : le même serveur en syntaxe CommonJS (require)
    const http = require('node:http');
    
    const serveur = http.createServer((req, res) => {
      res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
      res.end('Hello World');
    });
    
    serveur.listen(3000, '127.0.0.1', () => {
      console.log('Serveur démarré sur http://127.0.0.1:3000/');
    });
  20. import est la syntaxe standard de JavaScript (modules ES), la même que dans le navigateur, dans Angular ou dans React. C'est celle de ce cours ; elle s'active avec "type": "module" dans package.json. Un fichier d'extension .cjs utilise toujours CommonJS, un fichier .mjs toujours les modules ES. Les deux syntaxes sont comparées en détail au chapitre 4.
  21. res.writeHead(200, { … }) est un raccourci qui fixe le code de statut et les en-têtes en une seule instruction.
  22. Activité 1 : explorer le REPL

    • Dans le REPL :
      1. calculez le prix TTC de 250 dinars avec une TVA de 19 %, puis utilisez _ pour calculer le prix de 3 articles ;
      2. affichez toutes les fonctions de l'objet Math avec la touche Tab, et utilisez-en une pour arrondir 12,6 ;
      3. passez en mode .editor, écrivez une fonction carre(n), puis appelez carre(9);
      4. enregistrez votre session avec .save session.js.
    • Voir le corrigé
      > 250 * 1.19
      297.5
      > _ * 3
      892.5
      > Math.round(12.6)
      13
      > .editor
      // Entering editor mode (Ctrl+D to finish, Ctrl+C to cancel)
      function carre(n) {
        return n * n;
      }
      // (Ctrl + D)
      undefined
      > carre(9)
      81
      > .save session.js
      Session saved to: session.js
  23. Activité 2 : la table de multiplication

    • Écrivez le script table.js qui affiche la table de multiplication du nombre passé en argument : node table.js 7 affiche de « 7 x 1 = 7 » à « 7 x 10 = 70 ». Si l'argument manque ou n'est pas un entier, le script affiche un message d'utilisation et se termine avec le code 1.
    • Voir le corrigé
      // table.js : afficher la table de multiplication d'un nombre passé en argument
      const nombre = Number(process.argv[2]);
      
      if (!Number.isInteger(nombre)) {
        console.error('Usage : node table.js <nombre entier>');
        process.exit(1);
      }
      
      for (let i = 1; i <= 10; i++) {
        console.log(`${nombre} x ${i} = ${nombre * i}`);
      }
      node table.js 7
      7 x 1 = 7
      7 x 2 = 14
      …
      7 x 10 = 70
      
      node table.js abc
      Usage : node table.js <nombre entier>
  24. Activité 3 : une vraie page HTML

    • Modifiez le premier serveur pour qu'il renvoie une page HTML contenant un titre, la date et l'heure du serveur, et l'adresse demandée par le navigateur. Testez avec http://localhost:3000/contact.
    • Voir le corrigé
      // serveur-heure.js : une page HTML avec la date et l'heure du serveur
      import http from 'node:http';
      
      const serveur = http.createServer((req, res) => {
        const maintenant = new Date().toLocaleString('fr-FR');
        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
        res.end(`<!DOCTYPE html>
      <html lang="fr">
      <head><meta charset="utf-8"><title>Mon serveur</title></head>
      <body>
        <h1>Bienvenue sur mon serveur Node.js</h1>
        <p>Date et heure du serveur : <strong>${maintenant}</strong></p>
        <p>Adresse demandée : ${req.url}</p>
      </body>
      </html>`);
      });
      
      serveur.listen(3000, () => console.log('http://localhost:3000'));

      Le type de contenu devient text/html: le navigateur interprète alors les balises au lieu de les afficher. req.url contient l'adresse demandée (/contact) ; vous l'utiliserez au chapitre 7 pour afficher une page différente selon l'adresse. Rechargez la page : l'heure change à chaque requête, car la fonction est exécutée à chaque fois.

  25. À retenir

    • node seul ouvre le REPL; node fichier.js exécute un script ; node -e et node -p exécutent une instruction.
    • process.argv contient les arguments du script (à partir de l'indice 2), toujours sous forme de chaînes.
    • Le module readline pose des questions dans le terminal ; console propose error, table et time.
    • Un serveur web se crée avec http.createServer(): la fonction reçoit req et res à chaque requête, et listen() le démarre. Ctrl + C l'arrête.
    • Ce cours utilise import (modules ES) ; require est l'ancienne syntaxe CommonJS.
  26. Testez-vous

    • 1. Que contient la variable _ dans le REPL ?
    • 2. Avec node calcul.js 4 5, que vaut process.argv[3], et de quel type est-il ?
    • 3. Pourquoi un script se termine-t-il tout seul, alors qu'un serveur reste actif ?
    • 4. Que se passe-t-il si l'on oublie res.end()?
    • 5. Quelle ligne de package.json permet d'utiliser import dans des fichiers .js?
    • Voir les réponses
      1. Le résultat de la dernière expression évaluée.
      2. '5': une chaîne de caractères (indice 2 = '4', indice 3 = '5').
      3. Un script n'a plus rien à faire une fois son code exécuté ; un serveur attend des requêtes, il reste donc actif jusqu'à son arrêt.
      4. La réponse n'est jamais terminée : le navigateur reste en chargement.
      5. "type": "module".

Cet article vous a-t-il aidé ?