Čtení velkých JSON v Node.js: streamované parsování se stream-json a backpressure v praxi
Shrnutí: Čtení pole JSON o 186MB přes readFileSync a JSON.parse vyhání paměť k vrcholu 612MB; přechod na streamArray ze stream-json ji drží plochou na 104MB. Článek porovnává čtyři strategie čtení podle měření, vysvětluje, proč for await dává backpressure zdarma, jak ji událost data ztrácí a jak nastavit highWaterMark a drain na straně zápisu.

Když import souboru JSON o 186MB vytlačí proces na 600MB paměti, vinen není rozměr souboru — JSON.parse vyměnil celý text za celý graf objektů na jeden zátah. Změňte strategii čtení a křivka paměti se vyrovná.
Jeden symptom: soubor 186MB s vrcholem 612MB
Importní úlohy na serveru jsou hlavní oblastí tohoto problému: plánované synchronizace objednávek, čištění logů, hromadné nahrávání historie. Typická implementace vypadá takto:
const fs = require('fs');
const raw = fs.readFileSync('./orders.json', 'utf8');
const orders = JSON.parse(raw);
for (const order of orders) await saveToDb(order);
Tento vzor jsme měřili na Node 22.13. Vzorek: pole 480 000 záznamů objednávek, soubor 186MB s řetězci, vnořenými objekty a poli v atributech, napodobující reálnou strukturu byznysu. Vrchol Maximum resident set size dle /usr/bin/time -v: soubor se přečte za 1.3 sekundy, ale RSS dosáhne 612MB — 3.3násobek souboru. Při výchozím limitu old space V8 1.4–2GB stačí pár takových úloh paralelně, aby kontejner skončil jako OOM Kill.
Aritmetika není exotická: syrový text zabírá jednu kopii v paměti (asi 186MB), graf objektů po parse druhou (každý řetězcový klíč, každá hlavička vnořeného objektu a každé pole má režii) a proces parsování sám dočasně alokuje navrch. Vrchol 600MB je normální.
Druhá příčina: JSON.parse vyměňuje celý text za celý graf
Smlouva JSON.parse: „dej mi kompletní text — dostaneš kompletní graf". Vyžaduje, aby celý text byl na místě předem, a výsledek vydá až po skončení. Žádný mechanismus „nejprve prvních 1 000 záznamů" neexistuje.
Náklady na graf objektů byly změřeny položku po položce v článku Účet paměti JSON: každý řetězec zabírá skutečné místo, každý klíč objektu jeden slot a šířka pole závisí na typech prvků. Pár desítek MB JSON se po parsování pravidelně zvětší na trojnásobek až pětinásobek, vrchol se přidává navrch.
Většina importních úloh ale celý graf nikdy nepotřebuje: vkládat řádek po řádku, filtrovat řádek po řádku, transformovat řádek po řádku — každý záznam lze uvolnit hned po zpracování. Úloha potřebuje schopnost „rozebral jsem záznam — vydám záznam". To je právě definice streamovaného parsování.
Řešení: streamArray dodává záznam po záznamu a for await dává backpressure zdarma
stream-json implementuje parser jako Transform stream, který spotřebovává tokeny a nikdy nečeká celý soubor. Když nejvyšší úroveň je pole, streamArray() vydá {key, value} v okamžiku, kdy každý prvek dokončí parsování:
const fs = require('fs');
const { chain } = require('stream-chain');
const { parser } = require('stream-json');
const { streamArray } = require('stream-json/streamers/StreamArray');
async function importOrders(filePath) {
const pipeline = chain([
fs.createReadStream(filePath, { highWaterMark: 64 * 1024 }),
parser(),
streamArray(),
]);
for await (const { key, value } of pipeline) {
await saveToDb(value);
}
}
Na stejném souboru 186MB se stejnými 480 000 záznamy má tato verze vrchol RSS 104MB, plochý po celou dobu. V paměti existují vždy jen „aktuální prvek + stav parseru"; dokončené záznamy se uvolňují okamžitě.
Detail, který snadno unikne: for await netáhne další záznam z parseru, dokud saveToDb nedokončí, takže parser přeruší čtení souboru. Pomalejší databáze, pomalejší čtení — to je backpressure, vzniklá přirozeně, bez jediného řádku navíc. Rozbor na dev.to o příjmu komunálního feedu na 4GB používá stejný řetěz s pick({filter:'data'}) a hlásí stejně rovnou křivku paměti.
Když selhává strana zápisu: událost data bez pauzy vytlačí paměť zpět nahoru
Streamované parsování káží jen straně čtení. Pokud zápis nepřijme backpressure, paměť znovu roste. Klasický propad: asynchronní zápis uvnitř handleru data bez ohledu na buffer writable:
// Špatně: událost data + asynchronní zápis, backpressure zcela ztracena
readable.on('data', async (chunk) => {
await slowWrite(chunk); // stream nečeká; buffer se dál nafukuje
});
V režimu data stream dál plyne, bez ohledu na to, jak je slowWrite pomalý, a vše se hromadí ve vnitřním bufferu writable. Na stejném vzorku 186MB jsme záznamy směrovali do pomalého Writable, který zdržuje 1ms každý stý chunk. Bez zacházení s backpressure vrcholil RSS na 407MB; s pozastavením přes await once(sink, 'drain'), když write() vrací false, na 161MB. Rozdíl 246MB jsou doslova data, sedící v zápisovém bufferu.
// Správně: pauza, když write() vrací false, pokračování na drain
for await (const { value } of pipeline) {
if (!sink.write(value)) {
await once(sink, 'drain');
}
}
Ještě dvě terénní poznámky: při ručním skládání řetězce streamů nastavujte highWaterMark explicitně na každém streamu — typických 16 v objectMode je na velké objekty příliš velkorysých; a preferujte pipeline() ze stream/promises místo pipe(), který převezme šíření chyb a úklid.
Měření: vrchol paměti čtyř strategií
| Strategie | Vzorek | Vrchol RSS | Doba | Použití |
|---|---|---|---|---|
| readFileSync + JSON.parse | 186MB / 480 tis. | 612MB | 1.3s | malé soubory, náhodný přístup |
| streamArray + for await + pomalé zápisy do DB (0.5ms každý) | tentýž | 104MB (plochý) | diktuje DB | záznamový příjem, transformace |
| streamArray + zápisy přes data, bez backpressure | tentýž | 407MB | ~10s | jak to nedělat |
| streamArray + write()/drain | tentýž | 161MB | ~10s | zápis na disk nebo posílání dál |
Prostředí: Node 22.13, Maximum resident set size z /usr/bin/time -v, syntetický vzorek s byznysově tvarovanými atributy, jednotlivé běhy bez průměrování, simulace pomalého zápisu přes setTimeout. Tato čísla jsou závěry o řádu velikosti pro tento vzorek, ne univerzální konstanty — měřte na svých datech.
Dva údaje si zasluhují pozornost. První a druhá strategie se liší šestinásobně v paměti, za cenu výměny „1.3 sekundy" za „rychlost DB". Třetí a čtvrtá se liší 2.5násobně: streamované čtení bez backpressure na zápisu řeší jen polovinu úkolu.
Diagnostika: ověřit, že backpressure skutečně funguje
Problémy paměti v produkci se neřeší intuicí. Materiál Tencent Cloud o hledání závad backpressure dává praktický plán:
- Dočasně logujte události
'pause'a'resume'na kritických streamech. Pokud potrubí s velkým objemem nikdy nepauzuje, někde se data hromadí v paměti; - Sledujte
writable.writableLength— trvalý růst znamená, že buffer se nikdy nevysype; - Vzorkujte RSS přes
process.memoryUsage()po intervalech a kreslete křivku, rozlišujte „rampový růst" (hromadění) a „pilovitou stabilitu" (zdravé uvolňování).
Při sémantice for await musí se události pause a resume střídat; pokud nespouštějí nikdy, hlejte přebytečný listener data nebo zapomenuté await.
Kdy streamování není odpověď
Streamování není výchozí odpověď. U souborů o pár desítkách MB s náhodným přístupem podle klíče je jediné volání JSON.parse jednodušší a levnější. Otevírání velkého souboru v prohlížeči je jiné téma — jak otevřít velký JSON soubor popisuje žebřík prohlížečů. Hranice použití streamovaného parsování jsou jasné:
- nejvyšší úroveň je pole (nebo data lze štěpit jako JSONL), spotřeba je sekvenční, bez pohledů zpět;
- rozměr souboru není kontrolovatelný nebo hluboko přesahuje rezervu heapu, a jeden import nesmí zdvojnásobit stopu procesu;
- konzument má přirozený rozdíl rychlosti (zápisy do DB, volání API po proudu), takže potřebuje backpressure, ne plnojemnou hadici.
Když je tvar nejvyšší úrovně nepravidelný, nejdřív se podívejte na strukturu v nástroji JSON parser a formátovač; ekvivalent na příkazové řádce popisuje článek jq pro velké JSON — jq --stream a streamArray jsou tatáž idea ve dvou runtimech.
FAQ
O kolik je stream-json pomalejší než JSON.parse?
V čistém parsování vyhrává JSON.parse: 1.3 sekundy na vzorku 186MB proti zhruba 7 sekundám u streamArray bez zpoždění zápisu (tokenové parsování plus stavba objektů po záznamech). Zisk streamování leží celý na straně paměti: vrchol klesne z 612MB na 104MB. Import stejně brzdí zápis do DB, takže zaplatit pár sekund parsování navíc za šestinásobnou paměťovou rezervu je obvykle dobrý obchod; uvnitř odpovědí API v milisekundách ne.
Je backpressure od for await totéž co ruční pause/resume?
Sémanticky ano: for await pozastaví čitelný stream, dokud tělo smyčky nedoběhne, což se rovná volání pause(), když write() vrací false, a resume() na drain. Rozdíl je v tom, že mechanika jazyka vede účetnictví a nic nezapomene; ruční propojení ztratí backpressure celého řetězce, jakmile jediné místo unikne.
Co když nejvyšší úroveň je jeden obrovský objekt?
stream-json nabízí streamObject() (vydává po klíčích) a filtr Pick (parsuje jen zvolený podstrom). Když stačí pár atributů, Pick s JSONPath zúží celý graf na požadovaný podgraf. Vícedokumentový vstup (JSON Lines, JSON sekvence) je lepší štěpit po řádcích a zpracovávat jako samostatné dokumenty.
Jak zapsat výsledek jako JSONL nebo jej poslat dál?
Strana zápisu je tatáž otázka backpressure: fs.createWriteStream i http.request vyžadují kontrolu návratové hodnoty write() a čekání once(stream, 'drain') při false — nebo připojte writable do pipeline(). Ověření je jednoduché: křivka RSS po průchodu musí být stabilní a writableLength nesmí rostout trvale.
Jaký je nejrychlejší monitor paměti pro importní úlohu?
Minimální verze: časovač, který každých 100ms vzorkuje process.memoryUsage().rss do pole a na konci vytiskne maximum. Přesnější: /usr/bin/time -v node task.js dává rovnou Maximum resident set size. V kontejnerech držte linku alarmu na 70% limitu paměti a nechte rezervu pro GC.