Node.js
V8, Event Loop, process, __dirname, __filename
Utilisez les flèches, cliquez ou glissez pour naviguer
1. Comprendre Node.js
Pourquoi il existe et ce qu'il permet (serveurs, fichiers, CLI)
2. Connaître le moteur V8
Compile le JS en code machine
3. Schéma mental de l'event loop
Single-threaded mais non-bloquant
4. Utiliser process, __dirname, __filename
Variables globales spécifiques à Node.js
5. Navigateur vs Node.js
DOM vs fs, window vs process — deux environnements, même langage
JavaScript hors du navigateur
Pourquoi Node.js existe — serveurs, fichiers, CLI
Le moteur V8
Compile le JS en code machine — Node.js = V8 + APIs système
Navigateur vs Node.js
DOM vs fs, window vs process — même langage, environnements différents
L'event loop simplifié
Analogie du serveur de restaurant — single-threaded mais non-bloquant
Live coding : process & variables globales
process.argv, process.cwd(), __dirname, __filename, process.exit()
Pourquoi Node.js existe
🖥️
Serveurs web
API REST, HTTP
📁
Fichiers & OS
Lire, écrire, parcourir
⚙️
Outils CLI
Scripts, automatisation
Node.js = V8 (moteur JS) + fonctionnalités système
Fichiers, réseau, processus OS — tout ce qu'un navigateur n'a pas
Avant Node.js (2009)
JS = uniquement dans le navigateur
Pour un serveur → PHP, Ruby, Python...
Un développeur devait apprendre 2 langages
Après Node.js
JS = partout — client ET serveur
npm, outils de build, APIs, scripts...
✅ Un seul langage pour tout le stack
💡 Ryan Dahl crée Node.js en 2009 — aujourd'hui utilisé par Netflix, LinkedIn, PayPal...
Le cerveau derrière Node.js
Développé par Google pour Chrome
Compile le JavaScript en code machine natif
📝
Code JS
console.log("hello")
⚙️
V8 compile
Parse → AST → Bytecode → JIT
💻
Code machine
Exécution native rapide
Node.js = V8 + libuv + APIs système
V8
Exécute le JS
libuv
Event loop & I/O async
APIs
fs, http, os, path...
Même langage, environnements différents
🌐
Navigateur
DOM, window, fetch, localStorage...
🖥️
Node.js
fs, http, process, __dirname...
⚠️ Piège courant : les étudiants cherchent document et window dans Node.js — ça n'existe pas !
Single-threaded mais non-bloquant
Comment Node.js gère des milliers de requêtes
avec un seul fil d'exécution ?
Un seul serveur, de nombreuses tables — il ne reste pas bloqué devant une table à attendre la cuisine !
Prend la commande
= reçoit une requête
Transmet en cuisine
= délègue l'I/O au système (libuv)
Va servir d'autres tables
= traite d'autres requêtes pendant ce temps
Cuisine l'appelle : plat prêt !
= callback exécuté quand l'I/O termine
// Non-bloquant ✅
fs.readFile('data.txt', (err, data) => {
// appelé quand le fichier est lu
console.log(data);
});
console.log('Je continue ici !');
// Affiche "Je continue ici !" d'abord
Call Stack
Fonctions en cours d'exécution
Node APIs / libuv
Opérations I/O en arrière-plan
Callback Queue
Callbacks prêts à s'exécuter
💡 Rester sur l'analogie du restaurant — ne pas entrer dans les détails des microtasks/macrotasks
process, __dirname, __filename
Les variables globales de Node.js
Toujours disponibles, sans import
__dirname
Le dossier absolu du script actuel
// Dans /home/user/projet/index.js
console.log(__dirname);
// → /home/user/projet
__filename
Le chemin absolu du fichier actuel
// Dans /home/user/projet/index.js
console.log(__filename);
// → /home/user/projet/index.js
Cas d'usage concret : construire des chemins fiables
const path = require('path');
const fichier = path.join(__dirname, 'data', 'users.json');
// → /home/user/projet/data/users.json
Tableau contenant tous les arguments passés à la commande
// Commande : node index.js Alice 25
console.log(process.argv);
// [
// '/usr/bin/node', <-- process.argv[0]
// '/home/user/index.js', <-- process.argv[1]
// 'Alice', <-- process.argv[2] ✅
// '25' <-- process.argv[3] ✅
// ]
⚠️ Piège : argv[0] et argv[1] ne sont PAS vos arguments !
const args = process.argv.slice(2); // ✅ Toujours slice(2)
console.log(args); // ['Alice', '25']
process.cwd()
Répertoire de travail courant — là où vous avez lancé node
console.log(process.cwd());
// → /home/user/mon-projet
process.exit()
Terminer le programme avec un code de sortie
// 0 = succès, 1 = erreur
if (!args[0]) {
console.log('Arg manquant');
process.exit(1);
}
// Résumé des globales process utiles
process.argv // arguments CLI (Array)
process.cwd() // répertoire courant
process.env // variables d'environnement
process.exit(0) // quitter le programme
// saluer.js
const args = process.argv.slice(2);
if (args.length === 0) {
console.log('Usage : node saluer.js <prénom>');
process.exit(1);
}
const prenom = args[0];
console.log(`Bonjour, ${prenom} !`);
console.log(`Dossier : ${__dirname}`);
console.log(`Fichier : ${__filename}`);
console.log(`CWD : ${process.cwd()}`);
$ node saluer.js Alice
Bonjour, Alice !
Dossier : /home/user/projet
Fichier : /home/user/projet/saluer.js
CWD : /home/user/projet
❌ Chercher document ou window dans Node.js
document.getElementById('...'); // ReferenceError !
✅ Node.js n'a pas de DOM — c'est un environnement serveur
❌ Utiliser argv[0] ou argv[1] comme arguments utilisateur
// ❌ Faux
const nom = process.argv[1];
// ✅ Correct
const nom = process.argv[2];
// ou .slice(2)
⚠️ Confondre __dirname et process.cwd()
__dirname = dossier du fichier | process.cwd() = dossier de lancement
✅ Pour les chemins de fichiers → toujours préférer __dirname
Node.js = V8 + fonctionnalités système
Fichiers, réseau, OS — ce que le navigateur ne peut pas faire
Pas de DOM dans Node.js
document, window → n'existent pas côté serveur
process.argv pour les arguments CLI → toujours .slice(2)
__dirname pour le dossier du script, __filename pour le chemin complet
Node.js est single-threaded mais non-bloquant
Grâce à l'event loop — analogie du serveur de restaurant
Node.js
JS hors du navigateur — V8 + APIs système
V8
Moteur qui compile JS → code machine
Event Loop
Single-threaded non-bloquant — serveur de resto
process & globals
argv.slice(2), cwd(), __dirname, __filename
Des questions ?
node script.js — votre nouvel ami !