JSON Toolkit

Membaca JSON besar dalam Node.js: penghuraian streaming dengan stream-json dan backpressure dalam amalan

Inti pati: Membaca array JSON 186MB dengan readFileSync dan JSON.parse menolak memori ke puncak 612MB; bertukar kepada streamArray dari stream-json mengekalkannya rata di 104MB. Artikel ini membandingkan empat strategi bacaan dengan ukuran, menjelaskan mengapa for await menghasilkan backpressure secara semula jadi, bagaimana peristiwa data kehilangannya, dan cara mengatur highWaterMark serta drain di sisi tulis.

Pertengahan~5 min bacaanDiterbitkan 2026-11-17Dikemas kini 2026-11-17
Streaming fail JSON besar dalam Node.js: perbandingan streamArray dan backpressure

Apabila mengimport fail JSON 186MB menolak proses ke 600MB memori, bukan saiz fail yang bersalah — JSON.parse menukar keseluruhan teks dengan keseluruhan graf objek dalam satu tarikan. Tukar strategi bacaan dan lengkung memori menjadi rata.

Satu simptom: fail 186MB dengan puncak 612MB

Tugas import di pelayan ialah tempat utama masalah ini: penyegerakan pesanan berjadual, pembersihan log, pemuatan sejarah pukal. Pelaksanaan tipikal kelihatan begini:

const fs = require('fs');
const raw = fs.readFileSync('./orders.json', 'utf8');
const orders = JSON.parse(raw);
for (const order of orders) await saveToDb(order);

Kami mengukur pola ini pada Node 22.13. Sampel: array 480,000 rekod pesanan, fail 186MB dengan rentetan, objek bersarang dan array dalam medan, meniru struktur perniagaan sebenar. Puncak Maximum resident set size diukur dengan /usr/bin/time -v: fail dibaca dalam 1.3 saat, tetapi RSS mencapai 612MB — 3.3 kali ganda fail. Dengan had lalai old space V8 1.4–2GB, beberapa tugas sedemikian selari cukup untuk menjadikan kontena mangsa OOM Kill.

Aritmetiknya tidak eksotik: teks mentah mengambil satu salinan dalam memori (kira-kira 186MB), graf objek hasil parse mengambil salinan kedua (setiap kunci rentetan, setiap kepala objek bersarang dan setiap array membawa kosong tambahan), dan proses penghuraian sendiri memperuntukkan sementara di atasnya. Mencapai puncak 600MB adalah biasa.

Sebab kedua: JSON.parse menukar seluruh teks dengan seluruh graf

Kontrak JSON.parse: «beri saya teks penuh — dapat graf penuh». Ia menuntut keseluruhan teks sedia sebelum mula dan hanya menyerahkan hasil selepas selesai. Tiada mekanisme «ini dahulu 1,000 rekod pertama».

Kos graf objek telah diukur perkara demi perkara dalam Kira-kira memori JSON: setiap rentetan mengambil ruang sebenar, setiap kunci objek mengambil satu slot, dan lebar array bergantung pada jenis elemen. Beberapa dozen MB JSON secara rutin menjadi tiga hingga lima kali lebih besar selepas penghuraian, puncak bertambah di atasnya.

Namun kebanyakan tugas import tidak pernah perlukan keseluruhan graf: masuk baris demi baris, tapis baris demi baris, ubah baris demi baris — setiap rekod boleh dilepaskan sebaik sahaja diproses. Yang tugas perlukan ialah keupayaan «hurai satu rekod — serah satu rekod». Itulah tepat definisi penghuraian streaming.

Penyelesaian: streamArray membekal rekod demi rekod, dan for await memberikan backpressure percuma

stream-json melaksanakan penghurai sebagai Transform stream yang memakan token dan tidak pernah menunggu seluruh fail. Apabila aras teratas adalah array, streamArray() memancarkan {key, value} pada saat setiap elemen selesai dihurai:

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

Pada fail 186MB yang sama dengan 480,000 rekod yang sama, versi ini mempunyai puncak RSS 104MB, rata sepanjang tempoh. Dalam memori setiap masa hanya wujud «elemen semasa + keadaan penghurai»; rekod yang siap direklaim serta-merta.

Butiran mudah terlepas: for await tidak menarik rekod seterusnya daripada penghurai sehingga saveToDb selesai, jadi penghurai berhenti membaca fail. Pangkalan data lebih lambat, bacaan lebih lambat — itulah backpressure, terbentuk secara semula jadi, tanpa sebaris kod tambahan. Uraian dev.to tentang pengambilan suapan perbandaran 4GB menggunakan rantaian sama dengan pick({filter:'data'}) dan melaporkan lengkung memori sama rata.

Apabila sisi tulis gagal: peristiwa data tanpa jeda menolak memori kembali naik

Penghuraian streaming hanya mendisiplinkan sisi baca. Jika tulis tidak menerima backpressure, memori naik semula. Kegagalan klasik: menulis tak segerak dalam handler data tanpa menghiraukan buffer writable:

// Salah: peristiwa data + tulis tak segerak, backpressure hilang sepenuhnya
readable.on('data', async (chunk) => {
  await slowWrite(chunk); // stream tidak menunggu; buffer terus membengkak
});

Dalam mod data stream terus mengalir, walau sepelan mana slowWrite, dan segala-galanya menumpuk dalam buffer dalaman writable. Pada sampel 186MB yang sama, kami mengarahkan rekod ke sebuah Writable perlahan yang berlengah 1ms pada setiap chunk keseratus. Tanpa pengendalian backpressure puncak RSS mencecah 407MB; dengan penggantungan melalui await once(sink, 'drain') apabila write() memulangkan false, 161MB. Beza 246MB ialah literally data yang duduk dalam buffer tulis.

// Betul: jeda apabila write() memulangkan false, sambung semula pada drain
for await (const { value } of pipeline) {
  if (!sink.write(value)) {
    await once(sink, 'drain');
  }
}

Dua nota lapangan lagi: semasa menyambung rantaian stream secara manual, tetapkan highWaterMark secara eksplisit pada setiap stream — nilai lalai 16 dalam objectMode terlalu mewah untuk objek besar; dan utamakan pipeline() daripada stream/promises berbanding pipe(), yang mengambil alih penyampaian ralat dan pembersihan.

Ukuran: puncak memori empat strategi

Strategi Sampel Puncak RSS Tempoh Kegunaan
readFileSync + JSON.parse 186MB / 480 ribu 612MB 1.3s fail kecil, akses rawak
streamArray + for await + tulis DB perlahan (0.5ms setiap satu) sama 104MB (rata) mengikut rentak DB pengambilan rekod demi rekod, transformasi
streamArray + tulis melalui data, tanpa backpressure sama 407MB ~10s contoh buruk
streamArray + write()/drain sama 161MB ~10s tulis ke cakera atau hantar ke hilir

Persekitaran: Node 22.13, Maximum resident set size melalui /usr/bin/time -v, sampel sintetik dengan medan berbentuk perniagaan, larian tunggal tanpa pemurataan, simulasi tulis perlahan melalui setTimeout. Angka-angka ini ialah kesimpulan peringkat magnitud bagi sampel ini, bukan pemalar sejagat — ukur pada data anda sendiri.

Dua bacaan berbalas perhatian. Strategi pertama dan kedua berbeza enam kali ganda dalam memori, dengan harga pertukaran «1.3 saat» kepada «kelajuan DB». Ketiga dan keempat berbeza 2.5 kali ganda: bacaan streaming tanpa backpressure pada tulisan hanya menyelesaikan separuh tugas.

Diagnostik: pastikan backpressure benar-benar berfungsi

Masalah memori dalam produksi tidak diselesaikan dengan intuisi. Bahan Tencent Cloud tentang siasatan backpressure memberikan pelan praktik:

  1. Log sementara peristiwa 'pause' dan 'resume' pada stream kritikal. Jika talian paip berisipadu tinggi tidak pernah berjeda, di suatu tempat data menumpuk dalam memori;
  2. Perhatikan writable.writableLength — pertumbuhan berterusan bermakna buffer tidak pernah kering;
  3. Persampelkan RSS melalui process.memoryUsage() mengikut selang dan lukis lengkung, bezakan «pertumbuhan cerun» (penumpukan) dan «kestabilan bergerigi» (pelepasan sihat).

Dalam semantik for await, peristiwa pause dan resume wajib berselang; jika tidak pernah berlaku, cari pendengar data berlebihan atau await tertinggal.

Bilamana streaming bukan jawapan

Streaming bukan jawapan lalai. Untuk fail beberapa dozen MB dengan akses rawak mengikut kunci, satu panggilan JSON.parse lebih mudah dan murah. Membuka fail besar dalam pelayar ialah domain masalah lain — cara membuka fail JSON besar merangkumi tangga penampil. Sempadan penghuraian streaming jelas:

  • aras teratas adalah array (atau data boleh dipecah sebagai JSONL), penggunaan berjujukan, tanpa pandangan ke belakang;
  • saiz fail tidak terkawal atau jauh melebihi rizab heap, dan satu import tidak boleh menggandakan jejak proses;
  • pengguna mempunyai jurang kelajuan semula jadi (tulis DB, panggilan API di hilir), jadi perlu backpressure, bukan paip laju penuh.

Apabila bentuk aras teratas tidak sekata, lihat dahulu struktur dalam alat penghurai dan pemformat JSON; padanan baris arahan diliputi dalam jq untuk JSON besar — jq --stream dan streamArray ialah idea sama dalam dua runtime.

FAQ

Berapa lebih perlahan stream-json berbanding JSON.parse?

Dalam penghuraian tulen JSON.parse menang: 1.3 saat untuk sampel 186MB berbanding kira-kira 7 saat streamArray tanpa kelewahan tulis (penghuraian token tambah pembinaan objek rekod demi rekod). Manfaat streaming tinggal sepenuhnya di sisi memori: puncak turun dari 612MB ke 104MB. Import sudah pun terhad oleh tulis DB, jadi membayar beberapa saat penghuraian untuk margin memori enam kali ganda biasanya transaksi baik; dalam respons API milisaat, tidak.

Adakah backpressure for await sama dengan pause/resume manual?

Secara semantik ya: for await menggantung stream boleh baca selagi badan gelung belum selesai, bersamaan memanggil pause() apabila write() memulangkan false dan resume() pada drain. Bezanya: mekanik bahasa memegang perakaunan dan tidak melupakan apa-apa; pendawaian manual kehilangan backpressure keseluruhan rantaian begitu satu tempat terlepas.

Bagaimana jika aras teratas ialah satu objek raksasa?

stream-json menyediakan streamObject() (memancarkan mengikut kunci) dan penapis Pick (menghurai hanya subtree terpilih). Jika beberapa medan sahaja diperlukan, Pick dengan JSONPath mengecilkan keseluruhan graf kepada subgraf diperlukan. Input pelbagai dokumen (JSON Lines, jujukan JSON) lebih baik dipecah baris demi baris dan diproses sebagai dokumen bebas.

Bagaimana menulis hasil sebagai JSONL atau menghantar ke hilir?

Sisi tulis ialah soalan backpressure yang sama: fs.createWriteStream dan http.request menuntut semakan nilai pulangan write() dan penantian once(stream, 'drain') apabila false — atau sambungkan writable ke pipeline(). Sahkan dengan mudah: lengkung RSS selepas satu larian mesti stabil dan writableLength tidak boleh terus meningkat.

Apakah pemantau memori terpantas untuk tugas import?

Versi minimum: pemasa yang menyampel process.memoryUsage().rss setiap 100ms ke dalam array dan mencetak maksimum pada akhir. Lebih tepat: /usr/bin/time -v node task.js memberi terus Maximum resident set size. Dalam kontena, letakkan garis amaran pada 70% had memori untuk meninggalkan ruang GC.

Rujukan

Alat sepadan

Artikel berkaitan

jq dan fail JSON besar: mengapa -s meletupkan memori dan cara memproses secara streaming

Pengagregatan ratusan MB log JSON dengan jq -s berakhir dengan OOM, manakala reduce inputs menghasilkan statistik yang sama hanya dengan beberapa MB RAM. Diukur pada sampel 220 MB dan 2 juta baris: slurp memuncak pada 2,08 GB berbanding 3,5 MB untuk pengagregat streaming. Artikel ini menerangkan mekanisme penggunaan memori, pemprosesan JSONL baris demi baris, peristiwa laluan --stream dan tiga perangkap sebenar, termasuk output kosong senyap -n --stream.

Lanjutan~6 min bacaanDikemas kini 2026-11-12

Fail JSON besar tak boleh dibuka? Pilih alat yang betul mengikut saiz

Eksport JSON berpuluh MB kerap membekukan penyunting teks dan alat dalam talian, sedangkan penghuraian sendiri hanya mengambil beberapa ratus milisaat. Kami mengukur masa dan memori pada setiap peringkat untuk sampel 45 MB dengan 500,000 rekod, menunjukkan kos sebenar terletak pada bilangan baris dan nod, serta membina jadual pemilihan alat mengikut saiz fail: paparan dalam talian, baris perintah, pemprosesan strim dan aplikasi desktop.

Pertengahan~6 min bacaanDikemas kini 2026-11-07