JSONL en JavaScript : Lecture, écriture et analyse
Un guide complet pour travailler avec les fichiers JSONL (JSON Lines) en JavaScript. Apprenez à lire, écrire, analyser et streamer des données JSONL dans Node.js et le navigateur à l'aide des API natives et des bibliothèques populaires.
Dernière mise à jour : février 2026
Pourquoi JavaScript pour JSONL ?
JavaScript est naturellement adapté au travail avec les fichiers JSONL. JSON lui-même est né de JavaScript, le langage dispose donc d'un support d'analyse de premier ordre grâce aux méthodes natives JSON.parse() et JSON.stringify(). Que vous construisiez un pipeline de données Node.js, traitiez des fichiers journaux sur un serveur ou permettiez aux utilisateurs de téléverser du JSONL dans le navigateur, JavaScript vous donne les outils pour gérer chaque étape.
JSONL (JSON Lines) stocke un objet JSON par ligne, ce qui le rend idéal pour le streaming, la journalisation en ajout seul et le traitement de grands ensembles de données ligne par ligne. Les streams Node.js s'alignent parfaitement avec ce format, vous permettant de lire et transformer des millions d'enregistrements sans manquer de mémoire. Côté client, les API FileReader et Streams du navigateur permettent le traitement JSONL entièrement sur l'appareil de l'utilisateur. Dans ce guide, vous apprendrez à lire du JSONL dans Node.js et le navigateur, à écrire des fichiers JSONL, à construire des pipelines de transformation en streaming et à choisir la bonne bibliothèque npm pour votre projet.
Lecture de JSONL dans Node.js
Node.js fournit le module readline pour lire efficacement les fichiers ligne par ligne. Combiné avec fs.createReadStream, c'est la méthode recommandée pour traiter les fichiers JSONL sur le serveur car elle streame les données au lieu de charger le fichier entier en mémoire.
Utilisez fs.createReadStream canalisé vers readline.createInterface pour lire un fichier JSONL une ligne à la fois. Cette approche utilise un minimum de mémoire quelle que soit la taille du fichier.
import { createReadStream } from 'node:fs';import { createInterface } from 'node:readline';async function readJsonl(filePath) {const records = [];const rl = createInterface({input: createReadStream(filePath, 'utf-8'),crlfDelay: Infinity,});for await (const line of rl) {const trimmed = line.trim();if (trimmed) {records.push(JSON.parse(trimmed));}}return records;}// Usageconst data = await readJsonl('data.jsonl');console.log(`Loaded ${data.length} records`);console.log(data[0]);
Pour les petits fichiers JSONL qui tiennent confortablement en mémoire, vous pouvez lire le fichier entier d'un coup et le diviser par retour à la ligne. Cela sacrifie l'efficacité du streaming au profit de la simplicité.
import { readFileSync } from 'node:fs';const records = readFileSync('data.jsonl', 'utf-8').split('\n').filter(line => line.trim()).map(line => JSON.parse(line));console.log(`Loaded ${records.length} records`);
Lecture de JSONL dans le navigateur
Dans le navigateur, les utilisateurs peuvent téléverser des fichiers JSONL via un champ de fichier. Vous pouvez lire le fichier avec l'API FileReader ou l'API Streams moderne, le tout sans envoyer de données à un serveur.
Utilisez FileReader pour lire un fichier sélectionné par l'utilisateur, puis divisez le contenu texte en lignes et analysez chacune d'elles. Cela garde toutes les données côté client pour la confidentialité.
function parseJsonlFile(file) {return new Promise((resolve, reject) => {const reader = new FileReader();reader.onload = () => {const text = reader.result;const records = text.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));resolve(records);};reader.onerror = () => reject(reader.error);reader.readAsText(file, 'utf-8');});}// Usage with an <input type="file"> elementconst input = document.querySelector('input[type="file"]');input.addEventListener('change', async (e) => {const file = e.target.files[0];const records = await parseJsonlFile(file);console.log(`Parsed ${records.length} records`);});
Pour les gros fichiers dans le navigateur, utilisez l'API Streams avec TextDecoderStream pour traiter le fichier morceau par morceau. Cela évite de charger le fichier entier en mémoire d'un seul coup.
async function* streamJsonl(file) {const stream = file.stream().pipeThrough(new TextDecoderStream());const reader = stream.getReader();let buffer = '';while (true) {const { done, value } = await reader.read();if (done) break;buffer += value;const lines = buffer.split('\n');buffer = lines.pop(); // Keep incomplete last linefor (const line of lines) {const trimmed = line.trim();if (trimmed) yield JSON.parse(trimmed);}}// Handle remaining bufferif (buffer.trim()) {yield JSON.parse(buffer.trim());}}// Usagefor await (const record of streamJsonl(file)) {console.log(record);}
Écriture de JSONL dans Node.js
Écrire des fichiers JSONL dans Node.js est simple : sérialisez chaque objet JavaScript en chaîne JSON et ajoutez un caractère de retour à la ligne. Pour de meilleures performances avec de grands ensembles de données, utilisez un flux d'écriture au lieu de construire la chaîne entière en mémoire.
Utilisez fs.writeFileSync ou fs.createWriteStream pour écrire des enregistrements dans un fichier JSONL. Chaque enregistrement est une seule ligne de JSON valide suivie d'un retour à la ligne.
import { writeFileSync } from 'node:fs';const records = [{ id: 1, name: 'Alice', role: 'engineer' },{ id: 2, name: 'Bob', role: 'designer' },{ id: 3, name: 'Charlie', role: 'manager' },];const jsonl = records.map(record => JSON.stringify(record)).join('\n') + '\n';writeFileSync('output.jsonl', jsonl, 'utf-8');console.log(`Wrote ${records.length} records`);
Lors de l'écriture de millions d'enregistrements, utilisez un flux inscriptible pour éviter de construire la chaîne de sortie entière en mémoire. Le flux gère automatiquement la contre-pression, mettant en pause vos écritures lorsque le tampon du système est plein.
import { createWriteStream } from 'node:fs';async function writeJsonl(filePath, records) {const stream = createWriteStream(filePath, 'utf-8');for (const record of records) {const line = JSON.stringify(record) + '\n';// Respect backpressureif (!stream.write(line)) {await new Promise(resolve => stream.once('drain', resolve));}}stream.end();await new Promise(resolve => stream.on('finish', resolve));console.log('Write complete');}// Usageconst data = Array.from({ length: 100000 }, (_, i) => ({id: i + 1,value: Math.random(),timestamp: new Date().toISOString(),}));await writeJsonl('large_output.jsonl', data);
Flux Transform pour les pipelines JSONL
Les flux Transform de Node.js vous permettent de construire des pipelines de données composables qui lisent du JSONL, traitent chaque enregistrement et écrivent les résultats. Ce pattern est idéal pour les tâches ETL, le traitement de journaux et la migration de données.
import { createReadStream, createWriteStream } from 'node:fs';import { createInterface } from 'node:readline';import { Transform } from 'node:stream';import { pipeline } from 'node:stream/promises';// Transform: parse JSONL line into object, process, stringify backconst transformJsonl = new Transform({objectMode: true,transform(chunk, encoding, callback) {const line = chunk.toString().trim();if (!line) return callback();try {const record = JSON.parse(line);// Add your transformation hererecord.processed = true;record.processedAt = new Date().toISOString();callback(null, JSON.stringify(record) + '\n');} catch (err) {callback(err);}},});// Build the pipelineconst rl = createInterface({input: createReadStream('input.jsonl', 'utf-8'),crlfDelay: Infinity,});const output = createWriteStream('output.jsonl', 'utf-8');for await (const line of rl) {transformJsonl.write(line);}transformJsonl.end();await pipeline(transformJsonl, output);console.log('Pipeline complete');
Ce pipeline lit un fichier JSONL ligne par ligne, applique une transformation à chaque enregistrement (ajout des champs processed et processedAt) et écrit les résultats dans un nouveau fichier. Le flux Transform gère automatiquement la contre-pression, donc l'utilisation mémoire reste constante même pour de très gros fichiers. Vous pouvez chaîner plusieurs transformations pour des workflows ETL complexes.
Bibliothèques JavaScript pour JSONL
Bien que le JSON.parse natif gère la plupart des cas, plusieurs packages npm fournissent des utilitaires pratiques pour les workflows spécifiques à JSONL comme le streaming, la validation et le traitement par lots.
JSON.parse (natif)
NatifLes fonctions natives JSON.parse() et JSON.stringify() sont hautement optimisées dans V8 et suffisantes pour la plupart des cas d'utilisation JSONL. Combinez-les avec readline pour le streaming. Aucune dépendance nécessaire, et les performances sont excellentes pour des fichiers jusqu'à plusieurs centaines de Mo.
ndjson
Populairendjson est un package npm populaire qui fournit des parseurs et sérialiseurs JSONL (Newline Delimited JSON) en streaming compatibles avec les flux Node.js. Il gère les erreurs d'analyse avec élégance et s'intègre bien aux pipelines de flux existants. Idéal pour le prototypage rapide.
jsonl-parse-stringify
Simplejsonl-parse-stringify est une bibliothèque légère sans dépendances qui fournit des méthodes simples parse() et stringify() pour les données JSONL. Elle gère les cas limites comme les retours à la ligne en fin de fichier et les lignes vides. Idéale quand vous voulez une API synchrone propre sans configuration de flux.
Essayez nos outils JSONL gratuits
Pas envie d'écrire du code ? Utilisez nos outils en ligne gratuits pour visualiser, convertir et formater des fichiers JSONL directement dans votre navigateur. Tout le traitement se fait localement, vos données restent privées.