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.
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
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.
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`);}
Unixowe narzędzia wiersza poleceń są idealne do szybkiej inspekcji i przetwarzania dużych plików JSONL bez pisania kodu.
# 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
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.
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)
Monitoruj zużycie pamięci podczas przetwarzania, aby wcześnie wykrywać problemy i dostroić rozmiar partii.
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')
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.
# 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
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.
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')
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.
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')
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.