0.3Premier script & le REPL Node
node app.js et expérimenter dans le REPL interactif.Il est temps d'exécuter du code. Node offre deux façons de faire tourner du JavaScript, à connaître dès le départ. La première : le REPL (Read-Eval-Print Loop). En tapant simplement node (sans nom de fichier) dans le terminal, vous ouvrez un environnement interactif où vous saisissez du JavaScript ligne par ligne, et Node l'évalue immédiatement en affichant le résultat. « Read-Eval-Print Loop » décrit son cycle : il LIT ce que vous tapez, l'ÉVALUE (l'exécute), IMPRIME le résultat, et RECOMMENCE. Le REPL est parfait pour expérimenter : tester une expression, vérifier le comportement d'une fonction, explorer une API, faire un calcul rapide — sans créer de fichier. On en sort avec .exit ou Ctrl+C (deux fois). C'est votre « bac à sable » interactif.
La seconde façon, la principale pour le vrai travail : exécuter un fichier script. On écrit son code JavaScript dans un fichier .js (par exemple app.js), puis on le lance avec node app.js dans le terminal — Node exécute tout le fichier du début à la fin. C'est ainsi qu'on développe des applications réelles (un serveur, un script d'automatisation…). Le traditionnel premier programme est un console.log("Hello, Node!") dans un fichier, lancé avec node : voir le message s'afficher confirme que toute la chaîne fonctionne. Quelques éléments essentiels à connaître dès ce premier contact. console.log() : la fonction d'affichage dans le terminal (l'équivalent de « print » d'autres langages) — votre outil de base pour voir des valeurs, déboguer, tracer l'exécution. Node fournit aussi des objets globaux spécifiques à son environnement : process (informations et contrôle du processus en cours — arguments de ligne de commande via process.argv, variables d'environnement via process.env, sortie via process.exit()), __dirname et __filename (le chemin du dossier et du fichier courants), et l'objet global (l'équivalent de window du navigateur, mais côté Node). Notez cette différence fondamentale avec le JavaScript du navigateur : dans Node, il n'y a PAS de window, de document, de DOM (pas de page web) ; en revanche, on a accès au système (fichiers, réseau, processus) via des modules et objets globaux propres à Node. Ce premier contact — REPL pour expérimenter, fichiers .js pour développer, console.log et les globaux Node pour interagir — pose les gestes de base que vous répéterez sans cesse. Maîtriser ces deux modes d'exécution et ces outils fondamentaux, c'est être prêt à écrire de vrais programmes.
Vocabulaire de la section
- REPL
- Environnement interactif ouvert en tapant `node` seul : lit/évalue/imprime le JavaScript ligne par ligne. Idéal pour expérimenter sans créer de fichier.
- Exécuter un fichier
- La façon principale de travailler : écrire son code dans un fichier .js et le lancer avec `node fichier.js` (Node exécute tout le fichier).
- console.log()
- Fonction d'affichage dans le terminal (équivalent de « print ») ; outil de base pour voir des valeurs, déboguer et tracer l'exécution.
- process
- Objet global Node donnant accès au processus : arguments (process.argv), variables d'environnement (process.env), sortie (process.exit()).
- Globaux Node vs navigateur
- Node n'a PAS de window/document/DOM (pas de page web) ; il offre process, __dirname, __filename, global et l'accès au système.
Pourquoi choisir la version LTS de Node plutôt que la dernière ?
En pratique — Exécuter son premier code Node
- Ouvrez le REPL en tapant `node` seul dans le terminal ; testez quelques expressions (1 + 1, une chaîne, une fonction) puis sortez avec `.exit`.
- Créez un fichier `app.js` avec `console.log("Hello, Node!")` et lancez-le avec `node app.js` : le message doit s'afficher.
- Explorez les globaux Node : affichez `process.argv` (les arguments), `__dirname` (le dossier courant), et testez `process.env`.
- Constatez la différence avec le navigateur : `window` et `document` n'existent pas dans Node (pas de DOM) ; en revanche on accède au système.
Points clés à retenir
- Deux façons d'exécuter : le REPL (`node` seul, interactif, pour EXPÉRIMENTER) et les fichiers script (`node app.js`, pour DÉVELOPPER de vraies applications).
- console.log() = l'affichage terminal (équivalent de « print ») : outil de base pour voir des valeurs et déboguer.
- Objets globaux Node : `process` (arguments argv, env, exit), `__dirname`/`__filename` (chemins), `global` — spécifiques à l'environnement Node.
- Différence clé avec le navigateur : PAS de window/document/DOM dans Node ; en revanche, accès au système (fichiers, réseau, processus).
Questions fréquentes
Quelle différence entre le REPL et l'exécution d'un fichier, et quand utiliser lequel ?
Ce sont deux modes d'exécution complémentaires, chacun adapté à un usage — les distinguer vous fera travailler efficacement. Le REPL (mode interactif, ouvert avec node seul) fonctionne ligne par ligne : vous tapez une expression, Node l'évalue et affiche le résultat IMMÉDIATEMENT, puis attend la suivante. C'est un dialogue en temps réel avec Node. Ses usages idéaux : (1) Expérimenter rapidement : « que renvoie cette fonction ? », « comment se comporte cette méthode de chaîne ? », « quel est le résultat de ce calcul ? » — vous testez et voyez instantanément, sans créer de fichier. (2) Explorer une API ou un module : charger un module et essayer ses fonctions interactivement pour comprendre comment il marche. (3) Vérifier une idée : tester une petite logique avant de l'intégrer dans votre code. (4) Calculs ponctuels : Node comme calculatrice évoluée. Ses limites : le REPL est ÉPHÉMÈRE (ce que vous tapez n'est pas sauvegardé — fermez-le et tout est perdu) et peu pratique pour du code long ou structuré (écrire un programme entier ligne par ligne serait pénible, et la moindre faute de frappe est fastidieuse à corriger). Il n'est PAS fait pour développer de vraies applications. L'exécution de fichier (node app.js) est le mode principal du vrai travail : vous écrivez votre code dans un fichier .js (sauvegardé, éditable confortablement dans VS Code, versionnable avec Git), et Node exécute tout le fichier d'un coup. Ses usages : (1) Développer des applications : un serveur, un script, un outil — tout programme réel est un (ou des) fichier(s). (2) Code structuré et long : vous écrivez, relisez, corrigez, réorganisez votre code dans l'éditeur, avec toute la puissance de celui-ci (coloration, autocomplétion, débogage). (3) Code réutilisable et partageable : un fichier se sauvegarde, se partage, se versionne, se réexécute à volonté. (4) Projets réels : dès que vous dépassez l'expérimentation, vous travaillez en fichiers. Comment les utiliser ensemble en pratique : (1) Vous DÉVELOPPEZ dans des fichiers (le mode de travail principal). (2) Vous utilisez le REPL PONCTUELLEMENT pour tester une idée, vérifier un comportement, explorer une fonction — puis vous repassez au fichier. Par exemple : vous n'êtes pas sûr de comment une méthode de tableau fonctionne → vous ouvrez le REPL, vous la testez en deux lignes, vous comprenez, vous fermez le REPL et vous l'utilisez dans votre fichier. Le REPL est votre « brouillon » interactif ; les fichiers sont votre « travail » sauvegardé. Une nuance : pour du code un peu long à tester interactivement, il existe aussi des alternatives (des outils qui exécutent un fichier et rechargent à chaque modification, comme node --watch ou nodemon — utile en développement de serveur pour ne pas relancer manuellement). Mais le principe reste : REPL pour expérimenter vite et jetable, fichiers pour développer sérieusement et durablement. Adoptez ce réflexe : quand vous vous demandez « comment ça marche ? » ou « qu'est-ce que ça renvoie ? », le REPL est votre ami pour une réponse instantanée ; quand vous CONSTRUISEZ quelque chose, vous êtes dans des fichiers. Les deux font partie de la boîte à outils quotidienne du développeur Node.
Qu'est-ce qui change vraiment entre le JavaScript du navigateur et celui de Node ?
C'est une question essentielle si vous venez du JavaScript front-end, ou pour bien comprendre ce qu'est Node — car le LANGAGE est le même, mais l'ENVIRONNEMENT et ce qu'on peut faire diffèrent profondément. Ce qui est IDENTIQUE : le langage JavaScript lui-même. La syntaxe, les types (nombres, chaînes, tableaux, objets), les structures de contrôle (if, for, while), les fonctions, les classes, les Promises, async/await, tout ES6+ — c'est le MÊME JavaScript dans le navigateur et dans Node (les deux utilisent d'ailleurs le moteur V8). Si vous connaissez le JS moderne, vous connaissez le langage de Node. C'est tout l'intérêt : un seul langage à apprendre. Ce qui DIFFÈRE — l'environnement et les API disponibles : (1) Pas de DOM dans Node. Dans le navigateur, JavaScript manipule la PAGE WEB via le DOM : document, window, les éléments HTML, les événements de clic, etc. Node n'a RIEN de tout cela — il n'y a pas de page web, pas de document, pas de window, pas de DOM. Un code front-end qui manipule le DOM ne fonctionnera pas en Node (et inversement). (2) Accès au système dans Node. En contrepartie, Node donne accès à ce que le navigateur INTERDIT pour des raisons de sécurité : le SYSTÈME DE FICHIERS (lire/écrire des fichiers via le module fs), le RÉSEAU bas niveau (créer des serveurs, des connexions), les PROCESSUS (process), les variables d'environnement, le système d'exploitation (os). Un navigateur ne peut pas lire vos fichiers (sécurité) ; Node le peut (c'est fait pour ça — c'est un environnement serveur/système). (3) Objets globaux différents. Navigateur : window, document, localStorage, fetch (ce dernier aussi dans Node récent), etc. Node : process, __dirname, __filename, global (l'équivalent de window), require/modules, Buffer, etc. (4) Modules. Node a son système de modules (CommonJS require, et ES Modules import — section 1-3) pour organiser le code, et l'écosystème npm de paquets — un aspect central de Node. (5) Le contexte d'exécution. Le navigateur exécute du code lié à une page, déclenché par l'utilisateur (clics, chargement). Node exécute des scripts/serveurs, souvent en réponse à des requêtes réseau ou en tâche de fond. Ce que cela implique pour vous : (1) Le LANGAGE que vous apprenez (JS moderne, section 1-1) sert PARTOUT (front et back) — un acquis transversal précieux. (2) Les API et ce qu'on FAIT diffèrent : en Node, vous manipulez des fichiers, créez des serveurs, interrogez des bases — pas des pages web. (3) Certains concepts sont propres à Node : les modules natifs (fs, path, http…), l'asynchrone omniprésent (l'I/O), les objets globaux Node. Une image : le langage JavaScript est comme une langue (le français) ; le navigateur et Node sont deux « pays » où on parle cette langue mais où l'on fait des choses différentes (manipuler des pages web vs gérer des serveurs et des fichiers). Vous parlez la même langue, mais le vocabulaire spécialisé et les activités changent selon l'environnement. En pratique, venir du JS navigateur est un ATOUT pour apprendre Node (vous connaissez déjà le langage) ; il vous reste à apprendre l'environnement Node (ses modules, son asynchrone, le développement serveur) — ce que ce guide couvre. Et si vous débutez en JavaScript tout court, le niveau 1 vous donne les bases du langage, communes aux deux mondes. Retenez : même langage, environnements et pouvoirs différents — Node vous donne les clés du système et du serveur, là où le navigateur vous donnait celles de la page web.