Hoe grote JSONL-bestanden verwerken (1GB+)
Strategieën en best practices voor het efficiënt verwerken van JSONL-gegevens op gigabyte-schaal
Laatst bijgewerkt: februari 2026
Waarom grote JSONL-bestanden speciale behandeling nodig hebben
Wanneer JSONL-bestanden groter worden dan enkele honderden megabytes, wordt het laden ervan in het geheugen onpraktisch. Een JSONL-bestand van 1GB met complexe geneste objecten kan 3-5GB RAM verbruiken wanneer het wordt geparseerd naar Python-dictionaries of JavaScript-objecten. Dit kan je applicatie laten crashen of je systeem tot stilstand brengen.
Het belangrijkste voordeel van JSONL ten opzichte van gewone JSON is dat het regel voor regel kan worden verwerkt. Elke regel is een onafhankelijk JSON-document, wat betekent dat je nooit het hele bestand hoeft te laden. Deze streaming-capaciteit is wat JSONL het voorkeursformaat maakt voor grote datasets in machine learning, loganalyse en data-engineering.
Stream-leesstrategieën
De fundamentele aanpak voor het verwerken van grote JSONL-bestanden is ze regel voor regel te lezen en elk record onafhankelijk te verwerken. Hier zijn implementaties in populaire talen en tools.
De bestandsiteratie van Python is inherent geheugenefficiënt. De for-lus leest één regel tegelijk van schijf, waardoor het geheugengebruik constant blijft ongeacht de bestandsgrootte.
import jsondef process_large_jsonl(filepath: str) -> int:"""Process a large JSONL file line by line."""count = 0errors = 0with open(filepath, 'r', encoding='utf-8') as f:for line_num, line in enumerate(f, 1):line = line.strip()if not line:continuetry:record = json.loads(line)# Process your record herecount += 1except json.JSONDecodeError as e:errors += 1print(f'Line {line_num}: {e}')print(f'Processed {count} records, {errors} errors')return count
De readline-interface van Node.js biedt een efficiënte manier om bestanden regel voor regel te verwerken met streams, waardoor het geheugengebruik minimaal blijft, zelfs voor bestanden van meerdere gigabytes.
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 herecount++;} catch (err) {console.error(`Parse error: ${err.message}`);}}console.log(`Processed ${count} records`);}
Unix-opdrachtregeltools zijn perfect voor snelle inspectie en verwerking van grote JSONL-bestanden zonder code te schrijven.
# Count lines in a JSONL filewc -l data.jsonl# View first 10 recordshead -n 10 data.jsonl# View last 5 recordstail -n 5 data.jsonl# Pretty-print first recordhead -n 1 data.jsonl | jq .# Filter records with jqjq -c 'select(.age > 30)' data.jsonl# Extract specific fieldsjq -c {name, email} data.jsonl
Geheugenbeheertechnieken
Naast het basis regel-voor-regel lezen helpen deze technieken je om grote JSONL-bestanden efficiënter te verwerken.
Verwerk records in batches van 1.000-10.000 om geheugengebruik en verwerkingsefficiëntie in balans te brengen. Dit is vooral nuttig bij het schrijven naar databases of het maken van API-aanroepen.
import jsonfrom typing import Iteratordef 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 batchbatch = []if batch:yield batch# Usagefor batch in read_jsonl_batches('large.jsonl'):# Insert batch into databasedb.insert_many(batch)
Monitor het geheugengebruik tijdens de verwerking om problemen vroegtijdig op te sporen en je batchgrootte af te stemmen.
import jsonimport psutilimport osdef 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 recordif i % 100000 == 0:mem = process.memory_info().rss / 1024 / 1024print(f'Line {i:,}: {mem:.1f} MB')
Grote JSONL-bestanden splitsen
Soms moet je een groot JSONL-bestand opsplitsen in kleinere delen voor parallelle verwerking, uploaden naar services met groottelimieten, of het verdelen van werk over machines.
Het Unix split-commando is de snelste manier om een JSONL-bestand te splitsen. Het werkt direct met regels, wat het perfect maakt voor JSONL.
# Split into files of 100,000 lines eachsplit -l 100000 data.jsonl chunk_# Split into files of approximately 100MB eachsplit -b 100m data.jsonl chunk_# Add .jsonl extension to split filesfor f in chunk_*; do mv "$f" "$f.jsonl"; done
Voor meer controle over de splitsingslogica, zoals splitsen op een veldwaarde of het garanderen van evenwichtige uitvoergroottes.
import jsondef split_jsonl(input_path: str, lines_per_file: int = 100000):file_num = 0line_count = 0out_file = Nonewith 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 += 1out_file = open(f'part_{file_num:04d}.jsonl', 'w')out_file.write(line)line_count += 1if out_file:out_file.close()print(f'Split into {file_num} files')
Compressiestrategieën
JSONL-bestanden comprimeren uitzonderlijk goed omdat JSON-tekst een hoge redundantie heeft. Compressie kan bestandsgroottes met 70-90% verminderen, wat opslag bespaart en overdrachten versnelt.
De gzip-module van Python verwerkt gecomprimeerde JSONL-bestanden transparant. De .gz-extensie is een conventie die tools automatisch herkennen.
import gzipimport json# Reading gzipped JSONLwith gzip.open('data.jsonl.gz', 'rt', encoding='utf-8') as f:for line in f:record = json.loads(line)# Process record# Writing gzipped JSONLwith gzip.open('output.jsonl.gz', 'wt', encoding='utf-8') as f:for record in records:f.write(json.dumps(record) + '\n')
Compressievergelijking
Typische compressieratio's voor een JSONL-bestand van 1GB met gemengde gegevens:
gzip: 70-80% reductie (1GB naar 200-300MB), breed ondersteund
zstd: 75-85% reductie (1GB naar 150-250MB), snellere decompressie
lz4: 60-70% reductie (1GB naar 300-400MB), snelste snelheid
Geen compressie: snelste toegang, het beste voor frequente willekeurige leesbewerkingen
Grote bestanden verwerken in de browser
jsonl.co is ontworpen om JSONL-bestanden tot 1GB+ direct in je browser te verwerken. Het gebruikt streaming en Web Workers om bestanden lokaal te verwerken zonder ze naar een server te uploaden.
Dit betekent dat je gegevens privé blijven en je directe resultaten krijgt zonder te wachten op uploads. De viewer kan miljoenen records weergeven met virtueel scrollen, en alle conversietools ondersteunen streaming voor grote bestanden.
Probeer onze gratis JSONL-tools
Bekijk, valideer en converteer grote JSONL-bestanden direct in je browser. Geen uploads, geen bestandsgroottelimieten, 100% privé.