0.3Premier script & le REPL Node
L'essentiel en 30 secondes
- Deux modes : REPL pour expérimenter, fichier .js pour développer : node seul en interactif, node app.js pour le durable.
- console.log affiche dans le terminal : l'outil de base pour voir, tracer et déboguer vos valeurs.
- Globaux Node, pas de DOM : process, __dirname, global — et jamais window ni document dans Node.
Mini-cas filé — Salim exécute son premier Hello
Salim, développeur junior à Alger, ouvre le terminal : il tape node seul et teste 1 + 1 dans le REPL, puis en sort. Ensuite il crée app.js avec un console.log de bienvenue, l'exécute avec node app.js, affiche les arguments reçus et le dossier courant. Quand il cherche window par réflexe du front, Node lui répond que cela n'existe pas : il comprend qu'ici on accède au système, pas à une page. Sa chaîne aller-retour « éditer, lancer, lire » fonctionne.
Cas autonome de cette section : il revient dans le cours, le schéma, le script et le défi 48h de la section 0.3.
1. REPL et fichier script
Deux façons d'exécuter du JavaScript. Le REPL (Read-Eval-Print Loop) : en tapant node seul, vous ouvrez un environnement interactif qui évalue chaque ligne aussitôt — parfait pour expérimenter, tester une expression ou explorer une fonction (on en sort avec .exit). La façon principale : le fichier script. On écrit son code dans un .js et on le lance avec node app.js — c'est ainsi qu'on développe de vraies applications, sauvegardées et versionnables. Salim retient : REPL pour le brouillon jetable, fichier pour construire.
2. console.log et les globaux Node
console.log() affiche dans le terminal : l'équivalent de « print », votre outil de base pour voir des valeurs et déboguer. Node fournit des objets globaux propres : process (arguments via process.argv, environnement via process.env, sortie via process.exit()), __dirname et __filename (dossier et fichier courants), et global. Salim les affiche un par un dans son app.js à Alger et lit chaque valeur dans le terminal.
3. Node n'est pas un navigateur
Différence clé avec le front : dans Node, pas de window, document ni DOM — il n'y a pas de page web. En revanche, accès au système (fichiers, réseau, processus) via modules et globaux. Un code qui manipule le DOM ne tourne pas en Node, et inversement. Salim a collé ce rappel au-dessus de son écran : « ici, pas de page — des fichiers, des arguments, des processus ». Maîtriser ces deux modes et ces globaux, c'est être prêt à écrire de vrais programmes.
🔎 Exemple concret — 🔎 Exemple concret — Hello, Node !
console.log("Hello, Node !");
console.log(process.argv);
console.log(__dirname);
// lancer : node app.js SalimLecture : Salim voit son message, la liste des arguments puis le dossier courant.
Leçon : la chaîne éditer, lancer, lire fonctionne de bout en bout.
Vocabulaire de la section
- REPL
- Environnement interactif ouvert avec node seul : lit, évalue et imprime le JavaScript ligne par ligne ; idéal pour expérimenter.
Exemple simple : Salim tape 1 + 1 dans le REPL et lit aussitôt le résultat.
Ce que ce n'est pas : un fichier sauvegardé et versionnable.
Réflexe : ouvrir le REPL pour tester une idée avant de l'écrire en fichier.
- Exécuter un fichier
- Façon principale de travailler : écrire son code dans un .js et le lancer avec node fichier.js, qui exécute tout le fichier.
Exemple simple : Salim lance node app.js et voit son Hello s'afficher.
Ce que ce n'est pas : taper tout un programme ligne par ligne dans le REPL.
Réflexe : dès que cela dépasse deux lignes, passer en fichier.
- console.log()
- Fonction d'affichage dans le terminal ; outil de base pour voir des valeurs, tracer l'exécution et déboguer.
Exemple simple : Salim affiche chaque variable avec console.log avant de chercher plus loin.
Ce que ce n'est pas : un retour visuel dans une page web.
Réflexe : afficher d'abord, supposer ensuite.
- process
- Objet global Node sur le processus en cours : arguments (process.argv), environnement (process.env), sortie (process.exit()).
Exemple simple : Salim lit le prénom passé en argument via process.argv à Alger.
Ce que ce n'est pas : window ou document, qui n'existent pas dans Node.
Réflexe : lire argv pour tout petit outil en ligne de commande.
- Globaux Node vs navigateur
- Node offre process, __dirname, __filename et global avec accès système ; il n'a ni window, ni document, ni DOM.
Exemple simple : Salim remplace document par __dirname quand il cherche où il est.
Ce que ce n'est pas : le même environnement des deux côtés.
Réflexe : devant window is not defined, basculer en logique système.
En pratique — En pratique — Exécuter son premier code Node
- Ouvrez le REPL avec node seul ; testez quelques expressions puis sortez avec .exit, comme Salim.
- Créez app.js avec un console.log de bienvenue et lancez-le avec node app.js.
- Affichez process.argv et __dirname depuis le fichier ; relancez avec un argument (node app.js Salim).
- Constatez que window et document n'existent pas dans Node ; en revanche on accède au système.
Script prêt à dire — raconter sa première exécution (30 s)
« J'ai testé dans le REPL avec node seul, puis j'ai écrit app.js avec un console.log. Avec node app.js Salim, je vois mon message, mes arguments et mon dossier courant. Et j'ai vérifié : pas de window ici, on parle au système. »
À dire en montrant le terminal : d'abord le REPL, puis l'exécution du fichier avec argument.
Modèle copier-coller — mon premier app.js
const prenom = process.argv[2] || "Salim";
console.log("Hello, Node ! Bienvenue " + prenom + ".");
console.log("Dossier courant : " + __dirname);
console.log("Arguments recus : " + JSON.stringify(process.argv.slice(2)));Sans argument
Lancez node app.js sans rien : le modèle affiche Salim par défaut, puis relancez avec votre prénom pour voir process.argv changer.
Explorateur REPL
Avant le fichier : testez chaque ligne du modèle une par une dans le REPL, puis assemblez-les dans app.js — le brouillon devient durable.
Binôme à Alger
Salim dicte, son collègue tape : l'un lit le terminal à voix haute (message, dossier, arguments), l'autre vérifie chaque valeur affichée.
Réflexe débogage
Programme muet : ajoutez un console.log après chaque étape (entrée, calcul, sortie) et relancez — le plus vieux débogueur reste le plus rapide.
✓ Bonnes pratiques
- Utilisez le REPL pour tester une idée ou explorer une fonction.
- Développez dans des fichiers .js (sauvegardés, versionnables).
- Connaissez process, __dirname et global dès le départ.
✗ Pièges fréquents
- Écrire un programme entier dans le REPL éphémère.
- Chercher window ou document dans Node (ils n'existent pas).
- Oublier que console.log est l'outil de débogage de base.
Points clés à retenir
- Deux façons d'exécuter : le REPL (node seul, pour EXPÉRIMENTER) et les fichiers script (node app.js, pour DÉVELOPPER).
- console.log() = l'affichage terminal : outil de base pour voir des valeurs et déboguer.
- Objets globaux Node : process (argv, env, exit), __dirname et __filename, global — spécifiques à Node.
- Différence clé : PAS de window, document ni DOM dans Node ; en revanche, accès au système.
Défi 48h — appliquez demain
Créez app.js avec le modèle de Salim, lancez-le avec puis sans argument, et testez une ligne du fichier dans le REPL.
- Je lance le REPL et un fichier .js en expliquant quand utiliser chacun.
- Mon app.js affiche message, arguments et dossier courant.
- Je cite les globaux Node et l'absence de window et document.
Questions fréquentes
Quelle différence entre le REPL et l'exécution d'un fichier, et quand utiliser lequel ?
Le REPL (node seul) évalue ligne par ligne avec résultat immédiat : idéal pour expérimenter (tester une fonction, explorer un module, vérifier une idée). Il est éphémère : rien n'est sauvegardé, inadapté au code long. L'exécution de fichier (node app.js) exécute tout un .js sauvegardé, éditable dans VS Code et versionnable : c'est le mode du vrai travail (serveur, script, outil). En pratique : on développe en fichiers et on ouvre le REPL en brouillon ponctuel avant d'intégrer.
Qu'est-ce qui change vraiment entre le JavaScript du navigateur et celui de Node ?
Le langage est identique (syntaxe, types, fonctions, classes, Promises, async/await — même moteur V8). Ce qui change, c'est l'environnement : pas de DOM dans Node (ni document, ni window, ni éléments HTML), mais un accès au système interdit au navigateur (fichiers, réseau, processus via process, système via modules). Les globaux diffèrent (process, __dirname, global contre window, document) et Node a son écosystème npm. Venir du front est un atout : on connaît déjà la langue, il reste à apprendre l'environnement Node.
Quand utiliser le REPL plutôt qu'un fichier .js ?