Lire et écrire des fichiers avec Node.js
Versions sync vs async · JSON · CSV
Utilisez les flèches, cliquez ou glissez pour naviguer
1. Utiliser fs.readFileSync et fs.writeFileSync
Lire et écrire en mode synchrone
2. Comprendre sync vs async
Bloquant vs non-bloquant
3. Lire et parser du JSON
readFileSync + JSON.parse
4. Écrire un fichier CSV
À partir de données structurées
5. Lister le contenu d'un dossier avec fs.readdirSync
Parcourir les fichiers d'un répertoire
Le module fs
Natif à Node.js, permet de lire/écrire des fichiers sur le disque
readFileSync et writeFileSync
Lire et écrire en mode synchrone — simple pour commencer
Sync vs Async
Bloquant vs non-bloquant — sync aujourd'hui, async demain
Lire du JSON et écrire du JSON
readFileSync + JSON.parse · JSON.stringify + writeFileSync
Live coding
Lire un JSON d'étudiants, calculer les moyennes, écrire un CSV
File System — natif à Node.js
Pas besoin de npm install
Il est inclus dans Node.js par défaut
import fs from 'fs';
ES Modules (import)
import fs from 'fs';
Syntaxe TypeScript — recommandée
CommonJS (require)
const fs = require('fs');
Ancien style JavaScript — pas de types
💡 Avec TypeScript on utilise import — les types sont automatiques
📖
Lire
readFileSync
✏️
Écrire
writeFileSync
📁
Lister
readdirSync
Et aussi : appendFileSync, unlinkSync, mkdirSync, renameSync...
On se concentre sur lire, écrire et lister aujourd'hui
Lire un fichier en mode synchrone
Le programme attend que la lecture soit terminée
avant de passer à la ligne suivante
import fs from 'fs';
const contenu: string = fs.readFileSync('fichier.txt', 'utf-8');
console.log(contenu);
1er argument
Le chemin du fichier à lire
2e argument
L'encodage — obligatoire pour du texte!
⚠️ Sans 'utf-8', readFileSync retourne un Buffer et non un string!
// Fichier: bonjour.txt
Bonjour tout le monde!
Bienvenue dans Node.js
import fs from 'fs';
const contenu: string = fs.readFileSync('bonjour.txt', 'utf-8');
console.log(contenu);
// Résultat dans la console :
Bonjour tout le monde!
Bienvenue dans Node.js
Écrire dans un fichier en mode synchrone
Si le fichier n'existe pas → il est créé
Si le fichier existe → il est écrasé
import fs from 'fs';
fs.writeFileSync('message.txt', 'Bonjour Node.js!');
1er argument
Le chemin du fichier
2e argument
Le contenu à écrire (string)
💡 Pas besoin de 'utf-8' ici — writeFileSync écrit du texte par défaut
import fs from 'fs';
// Écrire
fs.writeFileSync('salut.txt', 'Salut tout le monde!');
// Lire pour vérifier
const contenu: string = fs.readFileSync('salut.txt', 'utf-8');
console.log(contenu);
// Résultat :
Salut tout le monde!
✅ Écrire puis lire — le flux naturel des opérations fichiers
Bloquant vs non-bloquant
Sync
Bloquant
Async
Non-bloquant
Le programme s'arrête et attend la fin de l'opération
// Ligne 1 : lecture du fichier
const data: string = fs.readFileSync('gros-fichier.txt', 'utf-8');
⏸️ Le programme est bloqué ici jusqu'à la fin de la lecture
// Ligne 2 : s'exécute SEULEMENT après la lecture
console.log('Fini!');
💡 OK pour les scripts et les petits fichiers — pas pour les serveurs web!
Le programme continue pendant que l'opération se fait en arrière-plan
// Ligne 1 : demande de lecture (non-bloquante)
fs.readFile('gros-fichier.txt', 'utf-8', (err, data) => {
console.log(data); // S'exécute quand c'est prêt
});
✅ Le programme continue immédiatement
console.log('Je suis déjà là!'); // Affiché en premier!
📌 Aujourd'hui : sync · Demain : async avec callbacks et Promises
readFileSync
⏸️ Bloquant
📝 Code simple et linéaire
🔧 Idéal pour les scripts CLI
❌ Pas pour les serveurs web
const data: string = fs.readFileSync('f.txt', 'utf-8');
readFile
▶️ Non-bloquant
📝 Callback ou Promise
🔧 Idéal pour les serveurs web
✅ Performant
fs.readFile('f.txt', 'utf-8', (err, data) => {});
readFileSync + JSON.parse
1️⃣ Lire le fichier texte avec readFileSync
2️⃣ Convertir le texte en objet JS avec JSON.parse
// Fichier: etudiants.json
[
{ "nom": "Alice", "note": 15 },
{ "nom": "Bob", "note": 12 }
]
1️⃣ Définir l'interface TypeScript
interface Etudiant {
nom: string;
note: number;
}
2️⃣ Lire le fichier
const texte: string = fs.readFileSync('etudiants.json', 'utf-8');
// texte est un STRING : '[{"nom":"Alice","note":15},...]'
3️⃣ Parser en objet typé
const etudiants: Etudiant[] = JSON.parse(texte);
// etudiants est un TABLEAU typé : [{nom: "Alice", note: 15}, ...]
✅ Maintenant on peut utiliser etudiants[0].nom, etudiants[0].note avec autocomplétion!
const etudiants: Etudiant[] = JSON.parse(
fs.readFileSync('etudiants.json', 'utf-8')
);
// Utilisation :
console.log(etudiants[0].nom); // "Alice"
console.log(etudiants[0].note); // 15
✅ C'est le pattern le plus courant pour lire du JSON en sync
JSON.stringify + writeFileSync
1️⃣ Convertir l'objet en texte avec JSON.stringify
2️⃣ Écrire le texte dans un fichier avec writeFileSync
interface Note { nom: string; note: number; }
const data: Note[] = [
{ nom: "Alice", note: 15 },
{ nom: "Bob", note: 12 }
];
fs.writeFileSync(
'resultat.json',
JSON.stringify(data, null, 2)
);
data
L'objet à convertir
null
Pas de filtre
2
Indentation de 2 espaces
💡 JSON.stringify(data, null, 2) produit du JSON lisible avec indentation
❌ Sans indentation
[{"nom":"Alice","note":15},{"nom":"Bob","note":12}]
Difficile à lire!
✅ Avec JSON.stringify(data, null, 2)
[
{
"nom": "Alice",
"note": 15
},
{
"nom": "Bob",
"note": 12
}
]
Lisible et propre!
Des chemins portables
Mac/Linux : / · Windows : \
path.join s'occupe du bon séparateur pour vous
import path from 'path';
// import.meta.dirname = dossier du fichier actuel (ES Modules)
const dir: string = import.meta.dirname;
const filePath: string = path.join(dir, 'data', 'etudiants.json');
❌ Chemin relatif — dangereux
fs.readFileSync('data/etudiants.json')
Dépend d'où on lance la commande!
✅ path.join + import.meta.dirname — portable
const dir = import.meta.dirname;
path.join(dir, 'data', 'etudiants.json')
Toujours le bon chemin, quel que soit l'OS
💡 path est aussi un module natif — pas de npm install
Lire du JSON → Calculer → Écrire du CSV
📖
Lire etudiants.json
🧮
Calculer les moyennes
✏️
Écrire resultats.csv
// data/etudiants.json
[
{ "nom": "Alice", "notes": [15, 12, 18] },
{ "nom": "Bob", "notes": [10, 14, 11] },
{ "nom": "Claire", "notes": [17, 16, 19] },
{ "nom": "David", "notes": [8, 11, 9] }
]
🎯 Objectif : calculer la moyenne de chaque étudiant et écrire un CSV
import fs from 'fs';
import path from 'path';
const dir: string = import.meta.dirname;
const filePath: string = path.join(dir, 'data', 'etudiants.json');
const etudiants: Etudiant[] = JSON.parse(
fs.readFileSync(filePath, 'utf-8')
);
✅ On a maintenant un tableau d'objets typés
interface Resultat { nom: string; moyenne: number; }
const resultats: Resultat[] = etudiants.map((etudiant): Resultat => {
const somme: number = etudiant.notes.reduce((acc, note) => acc + note, 0);
const moyenne: number = parseFloat((somme / etudiant.notes.length).toFixed(2));
return { nom: etudiant.nom, moyenne };
});
// resultats :
[{ nom: "Alice", moyenne: 15 }, { nom: "Bob", moyenne: 11.67 }, ...]
💡 reduce pour sommer, toFixed(2) pour arrondir à 2 décimales
// Construire le contenu CSV
let csv: string = 'Nom,Moyenne\n';
resultats.forEach((r: Resultat) => {
csv += `${r.nom},${r.moyenne}\n`;
});
// Écrire le fichier
const outputPath: string = path.join(import.meta.dirname, 'data', 'resultats.csv');
fs.writeFileSync(outputPath, csv);
// resultats.csv :
Nom,Moyenne
Alice,15
Bob,11.67
Claire,17.33
David,9.33
import fs from 'fs';
import path from 'path';
interface Etudiant { nom: string; notes: number[]; }
interface Resultat { nom: string; moyenne: number; }
// 1. Lire le JSON
const dir: string = import.meta.dirname;
const filePath: string = path.join(dir, 'data', 'etudiants.json');
const etudiants: Etudiant[] = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
// 2. Calculer les moyennes
const resultats: Resultat[] = etudiants.map((e): Resultat => ({
nom: e.nom,
moyenne: parseFloat((e.notes.reduce((a, n) => a + n, 0) / e.notes.length).toFixed(2))
}));
// 3. Écrire le CSV
let csv: string = 'Nom,Moyenne\n';
resultats.forEach((r) => csv += `${r.nom},${r.moyenne}\n`);
fs.writeFileSync(path.join(dir, 'data', 'resultats.csv'), csv);
console.log('CSV généré avec succès!');
Lister le contenu d'un dossier
Retourne un tableau avec les noms des fichiers
const fichiers: string[] = fs.readdirSync('./mon-dossier');
console.log(fichiers);
Résultat : un tableau de noms de fichiers
[ 'fichier1.txt', 'fichier2.json', 'image.png' ]
// Exemple : lister tous les fichiers JSON
const fichiers: string[] = fs.readdirSync('./data');
const jsonFiles: string[] = fichiers.filter((f: string) => f.endsWith('.json'));
console.log(jsonFiles); // ['etudiants.json', 'config.json']
Les erreurs que tout le monde fait
❌ L'erreur
const data: Buffer = fs.readFileSync('fichier.txt');
// Retourne : <Buffer 48 65 6c 6c 6f>
C'est un Buffer, pas un string!
✅ La solution
const data: string = fs.readFileSync('fichier.txt', 'utf-8');
// Retourne : "Hello"
C'est bien un string!
💡 Règle : toujours ajouter 'utf-8' quand vous lisez du texte
❌ L'erreur
fs.readFileSync('data/file.json', 'utf-8');
Le chemin dépend du répertoire d'où on lance node
$ cd /home/user
$ node project/app.js
// Cherche /home/user/data/file.json ❌
✅ La solution
const dir: string = import.meta.dirname;
const p: string = path.join(dir, 'data', 'file.json');
const content: string = fs.readFileSync(p, 'utf-8');
import.meta.dirname = dossier du fichier JS actuel
// Cherche /home/user/project/data/file.json ✅
readFileSync gèle tout le programme pendant la lecture
✅ OK pour les scripts CLI
Scripts qui s'exécutent une fois
Outils en ligne de commande
Tâches batch
❌ Pas pour les serveurs web
Express, Fastify, etc.
API qui sert plusieurs utilisateurs
Applications en temps réel
📌 Règle : sync pour les scripts, async pour les serveurs
fs est un module natif — pas besoin de npm install
readFileSync + 'utf-8' pour lire du texte
JSON.parse pour convertir le texte en objet
JSON.stringify(data, null, 2) pour du JSON lisible
path.join(import.meta.dirname, 'file.txt') pour des chemins portables
Fonctionne sur Mac, Windows et Linux
Sync bloque le programme — pour les scripts, pas pour les serveurs
readFileSync
Lire un fichier (ajouter 'utf-8')
writeFileSync
Écrire/créer un fichier
JSON.parse
String → Objet JS
JSON.stringify
Objet JS → String
path.join
Chemins portables
readdirSync
Lister un dossier
1. Lire un fichier texte et afficher son contenu
Utiliser readFileSync avec 'utf-8'
2. Écrire un fichier avec une liste de courses
Utiliser writeFileSync pour créer courses.txt
3. Lire un JSON de produits et afficher les noms
readFileSync + JSON.parse + forEach
4. Convertir un JSON en CSV
Lire produits.json, construire le CSV, écrire produits.csv
5. Lister tous les fichiers .json d'un dossier
readdirSync + filter + endsWith
Le module fs est la base du travail avec les fichiers dans Node.js
Prochaine leçon : les versions async avec callbacks et Promises