Comment gérer les gros fichiers JSONL (1 Go+)

Stratégies et bonnes pratiques pour traiter efficacement des données JSONL à l'échelle du gigaoctet

Dernière mise à jour : février 2026

Pourquoi les gros fichiers JSONL nécessitent un traitement spécial

Lorsque les fichiers JSONL dépassent quelques centaines de mégaoctets, les charger entièrement en mémoire devient impraticable. Un fichier JSONL de 1 Go contenant des objets imbriqués complexes peut consommer 3 à 5 Go de RAM lorsqu'il est analysé en dictionnaires Python ou en objets JavaScript. Cela peut faire planter votre application ou bloquer votre système.

L'avantage clé du JSONL par rapport au JSON classique est qu'il peut être traité ligne par ligne. Chaque ligne est un document JSON indépendant, ce qui signifie que vous n'avez jamais besoin de charger le fichier entier. Cette capacité de streaming est ce qui fait du JSONL le format préféré pour les grands jeux de données en apprentissage automatique, l'analyse de journaux et l'ingénierie des données.

Stratégies de lecture en streaming

L'approche fondamentale pour gérer les gros fichiers JSONL est de les lire ligne par ligne, en traitant chaque enregistrement indépendamment. Voici des implémentations dans les langages et outils populaires.

L'itération sur les fichiers en Python est intrinsèquement efficace en mémoire. La boucle for lit une ligne à la fois depuis le disque, maintenant une utilisation mémoire constante quelle que soit la taille du fichier.

Python
import json
def process_large_jsonl(filepath: str) -> int:
"""Process a large JSONL file line by line."""
count = 0
errors = 0
with open(filepath, 'r', encoding='utf-8') as f:
for line_num, line in enumerate(f, 1):
line = line.strip()
if not line:
continue
try:
record = json.loads(line)
# Process your record here
count += 1
except json.JSONDecodeError as e:
errors += 1
print(f'Line {line_num}: {e}')
print(f'Processed {count} records, {errors} errors')
return count

L'interface readline de Node.js offre un moyen efficace de traiter les fichiers ligne par ligne en utilisant des streams, maintenant une utilisation mémoire minimale même pour des fichiers de plusieurs gigaoctets.

Node.js
import { createReadStream } from 'fs';
import { createInterface } from 'readline';
async function processLargeJsonl(filepath) {
const rl = createInterface({
input: createReadStream(filepath, 'utf-8'),
crlfDelay: Infinity,
});
let count = 0;
for await (const line of rl) {
const trimmed = line.trim();
if (!trimmed) continue;
try {
const record = JSON.parse(trimmed);
// Process your record here
count++;
} catch (err) {
console.error(`Parse error: ${err.message}`);
}
}
console.log(`Processed ${count} records`);
}

Les outils en ligne de commande Unix sont parfaits pour l'inspection et le traitement rapides de gros fichiers JSONL sans écrire de code.

Outils en ligne de commande
# Count lines in a JSONL file
wc -l data.jsonl
# View first 10 records
head -n 10 data.jsonl
# View last 5 records
tail -n 5 data.jsonl
# Pretty-print first record
head -n 1 data.jsonl | jq .
# Filter records with jq
jq -c 'select(.age > 30)' data.jsonl
# Extract specific fields
jq -c {name, email} data.jsonl

Techniques de gestion de la mémoire

Au-delà de la lecture basique ligne par ligne, ces techniques vous aident à traiter les gros fichiers JSONL plus efficacement.

Traitez les enregistrements par lots de 1 000 à 10 000 pour équilibrer l'utilisation mémoire avec l'efficacité du traitement. C'est particulièrement utile lors de l'écriture en base de données ou lors d'appels API.

Traitement par lots
import json
from typing import Iterator
def read_jsonl_batches(
filepath: str,
batch_size: int = 5000
) -> Iterator[list]:
batch = []
with open(filepath, 'r') as f:
for line in f:
record = json.loads(line.strip())
batch.append(record)
if len(batch) >= batch_size:
yield batch
batch = []
if batch:
yield batch
# Usage
for batch in read_jsonl_batches('large.jsonl'):
# Insert batch into database
db.insert_many(batch)

Surveillez l'utilisation de la mémoire pendant le traitement pour détecter les problèmes tôt et ajuster la taille de vos lots.

Surveillance de la mémoire
import json
import psutil
import os
def process_with_monitoring(filepath: str):
process = psutil.Process(os.getpid())
with open(filepath, 'r') as f:
for i, line in enumerate(f):
record = json.loads(line)
# Process record
if i % 100000 == 0:
mem = process.memory_info().rss / 1024 / 1024
print(f'Line {i:,}: {mem:.1f} MB')

Découpage de gros fichiers JSONL

Parfois, vous devez découper un gros fichier JSONL en morceaux plus petits pour le traitement parallèle, le téléversement vers des services avec des limites de taille, ou la répartition du travail sur plusieurs machines.

La commande Unix split est le moyen le plus rapide de découper un fichier JSONL. Elle travaille directement avec les lignes, ce qui la rend parfaite pour le JSONL.

Utilisation de la commande split
# Split into files of 100,000 lines each
split -l 100000 data.jsonl chunk_
# Split into files of approximately 100MB each
split -b 100m data.jsonl chunk_
# Add .jsonl extension to split files
for f in chunk_*; do mv "$f" "$f.jsonl"; done

Pour plus de contrôle sur la logique de découpage, comme le découpage par valeur de champ ou la garantie de tailles de sortie équilibrées.

Script Python
import json
def split_jsonl(input_path: str, lines_per_file: int = 100000):
file_num = 0
line_count = 0
out_file = None
with open(input_path, 'r') as f:
for line in f:
if line_count % lines_per_file == 0:
if out_file:
out_file.close()
file_num += 1
out_file = open(f'part_{file_num:04d}.jsonl', 'w')
out_file.write(line)
line_count += 1
if out_file:
out_file.close()
print(f'Split into {file_num} files')

Stratégies de compression

Les fichiers JSONL se compressent extrêmement bien car le texte JSON a une redondance élevée. La compression peut réduire la taille des fichiers de 70 à 90 %, économisant du stockage et accélérant les transferts.

Le module gzip de Python gère de manière transparente les fichiers JSONL compressés. L'extension .gz est une convention que les outils reconnaissent automatiquement.

Lecture et écriture de JSONL compressé en gzip
import gzip
import json
# Reading gzipped JSONL
with gzip.open('data.jsonl.gz', 'rt', encoding='utf-8') as f:
for line in f:
record = json.loads(line)
# Process record
# Writing gzipped JSONL
with gzip.open('output.jsonl.gz', 'wt', encoding='utf-8') as f:
for record in records:
f.write(json.dumps(record) + '\n')

Comparaison de la compression

Taux de compression typiques pour un fichier JSONL de 1 Go avec des données mixtes :

gzip : réduction de 70-80 % (1 Go à 200-300 Mo), largement supporté

zstd : réduction de 75-85 % (1 Go à 150-250 Mo), décompression plus rapide

lz4 : réduction de 60-70 % (1 Go à 300-400 Mo), vitesse la plus rapide

Sans compression : accès le plus rapide, meilleur pour les lectures aléatoires fréquentes

Traitement de gros fichiers dans le navigateur

jsonl.co est conçu pour gérer des fichiers JSONL jusqu'à 1 Go+ directement dans votre navigateur. Il utilise le streaming et les Web Workers pour traiter les fichiers localement sans les téléverser vers un serveur.

Cela signifie que vos données restent privées et que vous obtenez des résultats instantanés sans attendre de téléversement. Le visualiseur peut afficher des millions d'enregistrements avec le défilement virtuel, et tous les outils de conversion prennent en charge le streaming pour les gros fichiers.

Essayez nos outils JSONL gratuits

Visualisez, validez et convertissez de gros fichiers JSONL directement dans votre navigateur. Sans téléversement, sans limite de taille, 100% privé.

Gérez les gros fichiers JSONL en ligne

Visualisez, validez et convertissez des fichiers JSONL jusqu'à 1 Go directement dans votre navigateur. Aucun téléversement requis, 100% privé.

Questions fréquemment posées

Gros fichiers JSONL (1 Go+) — Streaming, découpage, compr...