Jak obsługiwać duże pliki JSONL (1GB+)

Strategie i najlepsze praktyki wydajnego przetwarzania danych JSONL w skali gigabajtów

Ostatnia aktualizacja: luty 2026

Dlaczego duże pliki JSONL wymagają specjalnej obsługi

Gdy pliki JSONL przekraczają kilkaset megabajtów, ładowanie ich w całości do pamięci staje się niepraktyczne. Plik JSONL o rozmiarze 1GB ze złożonymi zagnieżdżonymi obiektami może zużywać 3-5GB RAM po sparsowaniu do słowników Python lub obiektów JavaScript. Może to spowodować awarię aplikacji lub zatrzymanie systemu.

Kluczowa zaleta JSONL w porównaniu ze zwykłym JSON polega na tym, że może być przetwarzany linia po linii. Każda linia jest niezależnym dokumentem JSON, co oznacza, że nigdy nie musisz ładować całego pliku. Ta możliwość strumieniowania sprawia, że JSONL jest preferowanym formatem dla dużych zbiorów danych w uczeniu maszynowym, analizie logów i inżynierii danych.

Strategie czytania strumieniowego

Fundamentalne podejście do obsługi dużych plików JSONL polega na czytaniu ich linia po linii, przetwarzając każdy rekord niezależnie. Oto implementacje w popularnych językach i narzędziach.

Iteracja po plikach w Python jest z natury wydajna pamięciowo. Pętla for czyta jedną linię naraz z dysku, utrzymując stałe zużycie pamięci niezależnie od rozmiaru pliku.

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

Interfejs readline Node.js zapewnia wydajny sposób przetwarzania plików linia po linii przy użyciu strumieni, utrzymując minimalne zużycie pamięci nawet dla plików wielogigabajtowych.

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`);
}

Unixowe narzędzia wiersza poleceń są idealne do szybkiej inspekcji i przetwarzania dużych plików JSONL bez pisania kodu.

Narzędzia wiersza poleceń
# 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

Techniki zarządzania pamięcią

Poza podstawowym czytaniem linia po linii, te techniki pomagają wydajniej przetwarzać duże pliki JSONL.

Przetwarzaj rekordy w partiach po 1000-10 000, aby zrównoważyć zużycie pamięci z wydajnością przetwarzania. Jest to szczególnie przydatne przy zapisie do baz danych lub wywoływaniu API.

Przetwarzanie wsadowe
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)

Monitoruj zużycie pamięci podczas przetwarzania, aby wcześnie wykrywać problemy i dostroić rozmiar partii.

Monitorowanie pamięci
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')

Dzielenie dużych plików JSONL

Czasami trzeba podzielić duży plik JSONL na mniejsze części do przetwarzania równoległego, przesyłania do usług z limitami rozmiaru lub dystrybucji pracy między maszynami.

Unixowe polecenie split jest najszybszym sposobem na podzielenie pliku JSONL. Działa bezpośrednio z liniami, co czyni je idealnym dla JSONL.

Użycie polecenia 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

Dla większej kontroli nad logiką dzielenia, np. dzielenie według wartości pola lub zapewnienie zrównoważonych rozmiarów plików wyjściowych.

Skrypt 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')

Strategie kompresji

Pliki JSONL kompresują się niezwykle dobrze, ponieważ tekst JSON ma wysoką redundancję. Kompresja może zmniejszyć rozmiar plików o 70-90%, oszczędzając miejsce na dysku i przyspieszając transfery.

Moduł gzip Python transparentnie obsługuje skompresowane pliki JSONL. Rozszerzenie .gz jest konwencją rozpoznawaną automatycznie przez narzędzia.

Czytanie i zapis skompresowanych plików JSONL (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')

Porównanie kompresji

Typowe współczynniki kompresji dla pliku JSONL o rozmiarze 1GB z mieszanymi danymi:

gzip: 70-80% redukcji (1GB do 200-300MB), powszechnie obsługiwany

zstd: 75-85% redukcji (1GB do 150-250MB), szybsza dekompresja

lz4: 60-70% redukcji (1GB do 300-400MB), najwyższa szybkość

Bez kompresji: Najszybszy dostęp, najlepszy do częstych losowych odczytów

Przetwarzanie dużych plików w przeglądarce

jsonl.co jest zaprojektowane do obsługi plików JSONL do 1GB+ bezpośrednio w przeglądarce. Wykorzystuje strumieniowanie i Web Workers do lokalnego przetwarzania plików bez przesyłania ich na żaden serwer.

Oznacza to, że Twoje dane pozostają prywatne i otrzymujesz natychmiastowe wyniki bez czekania na przesyłanie. Przeglądarka może wyświetlić miliony rekordów z wirtualnym przewijaniem, a wszystkie narzędzia konwersji obsługują strumieniowanie dla dużych plików.

Wypróbuj nasze bezpłatne narzędzia JSONL

Przeglądaj, waliduj i konwertuj duże pliki JSONL bezpośrednio w przeglądarce. Bez przesyłania, bez limitów rozmiaru pliku, 100% prywatności.

Obsługuj duże pliki JSONL online

Przeglądaj, waliduj i konwertuj pliki JSONL do 1GB bezpośrednio w przeglądarce. Bez przesyłania, 100% prywatności.

Najczęściej zadawane pytania

Duże pliki JSONL (1GB+) — strumieniowanie, dzielenie, kom...