JSON Toolkit

خواندن JSON بزرگ در Node.js: پارس جریانی با stream-json و فشار معکوس در عمل

جمع‌بندی: خواندن یک آرایه JSON ۱۸۶ مگابایتی با readFileSync و JSON.parse حافظه را به اوج ۶۱۲ مگابایت می‌رساند؛ با streamArray از stream-json منحنی در ۱۰۴ مگابایت ثابت می‌ماند. این مقاله چهار راهبرد خواندن را با اندازه‌گیری مقایسه می‌کند، توضیح می‌دهد چرا for await فشار معکوس را رایگان می‌سازد، رویداد data چگونه آن را از دست می‌دهد و highWaterMark و drain در سمت نوشتن چگونه تنظیم می‌شوند.

متوسطحدود 5 دقیقه مطالعهانتشار 2026-11-17به‌روزرسانی 2026-11-17
جریان‌دهی یک فایل JSON بزرگ در Node.js: مقایسه streamArray و فشار معکوس

وقتی واردکردن یک فایل JSON ۱۸۶ مگابایتی فرایند را به ۶۰۰ مگابایت حافظه می‌رساند، مقصر اندازه فایل نیست — JSON.parse تمام متن را یک‌جا با تمام گراف اشیا عوض کرده است. راهبرد خواندن را عوض کنید و منحنی حافظه صاف می‌شود.

یک نشانه: فایل ۱۸۶ مگابایتی با اوج ۶۱۲ مگابایت

کارهای واردات سمت سرور بیشترین محل بروز این مسئله‌اند: همگام‌سازی زمان‌بندی‌شده سفارش‌ها، پاکسازی لاگ‌ها، بارگذاری انبوه تاریخچه. پیاده‌سازی معمول چنین است:

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

این الگو را روی Node 22.13 اندازه گرفتیم. نمونه: آرایه‌ای از ۴۸۰,۰۰۰ رکورد سفارش، فایل ۱۸۶ مگابایت با رشته‌ها، اشیای تو در تو و آرایه‌ها در فیلدها، شبیه‌ساز ساختار واقعی کسب‌وکار. اوج Maximum resident set size با /usr/bin/time -v: فایل در ۱.۳ ثانیه خوانده می‌شود، اما RSS به ۶۱۲ مگابایت می‌رسد — ۳.۳ برابر فایل. با حد پیش‌فرض فضای قدیمی V8 در ۱.۴ تا ۲ گیگابایت، چند کار موازی از این نوع برای کشته‌شدن کانتینر با OOM Kill کافی است.

حساب‌ها پیچیده نیستند: متن خام یک نسخه در حافظه می‌گیرد (حدود ۱۸۶ مگابایت)، گراف اشیای حاصل از parse نسخه دوم را می‌گیرد (هر کلید رشته‌ای، هر سر شی تو در تو و هر آرایه هزینه دارد)، و خود فرایند پارس موقتاً بر آن می‌افزاید. رسیدن به اوج ۶۰۰ مگابایت طبیعی است.

علت دوم: JSON.parse تمام متن را با تمام گراف عوض می‌کند

قرارداد JSON.parse چنین است: «متن کامل را بده، گراف کامل بگیر». پیش از شروع، آماده‌بودن تمام متن را می‌طلبد و نتیجه را فقط در پایان می‌سپارد. هیچ سازوکاری برای «اول این ۱۰۰۰ رکورد را» وجود ندارد.

هزینه گراف اشیا در حساب حافظه JSON آیتم‌به‌آیتم اندازه‌گیری شده است: هر رشته فضای واقعی می‌گیرد، هر کلید شی یک خانه اشغال می‌کند، و پهنای آرایه به نوع عناصر بستگی دارد. چند ده مگابایت JSON پس از پارس مرتباً سه تا پنج برابر بزرگ‌تر می‌شود و اوج بر آن افزوده می‌شود.

اما بیشتر کارهای واردات هرگز به کل گراف نیاز ندارند: ردیف‌به‌ردیف درج، ردیف‌به‌ردیف فیلتر، ردیف‌به‌ردیف تبدیل — هر رکورد به‌محض پردازش می‌تواند آزاد شود. آنچه کار می‌خواهد «یک رکورد پارس شد، یک رکورد تحویل» است. این دقیقاً تعریف پارس جریانی است.

راه‌حل: streamArray رکوردبه‌رکورد مصرف می‌کند و for await فشار معکوس می‌سازد

stream-json پارسر را به‌صورت Transform Stream پیاده می‌کند که توکن‌به‌توکن پارس می‌کند و هرگز برای کل فایل منتظر نمی‌ماند. وقتی سطح بالا آرایه است، streamArray() در لحظه پایان پارس هر عنصر {key, value} صادر می‌کند:

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

روی همان فایل ۱۸۶ مگابایتی و همان ۴۸۰,۰۰۰ رکورد، این نسخه اوج RSS در ۱۰۴ مگابایت دارد، در تمام مدت اجرا صاف. در حافظه هر لحظه فقط «عنصر جاری + وضعیت پارسر» وجود دارد؛ رکوردهای تمام‌شده بی‌درنگ آزاد می‌شوند.

جزئیاتی که به‌راحتی از دست می‌رود: for await تا پایان saveToDb رکورد بعدی را از پارسر نمی‌کشد، پس پارسر خواندن فایل را متوقف می‌کند. دیتابیس کندتر، خواندن کندتر — این همان فشار معکوس است، طبیعی شکل‌گرفته، بدون حتی یک خط کد اضافه. گزارش dev.to درباره ورودی فید شهری ۴ گیگابایتی همین زنجیره را با pick({filter:'data'}) استفاده می‌کند و منحنی حافظه‌ای همان‌قدر صاف گزارش می‌کند.

وقتی سمت نوشتن شکست می‌خورد: رویداد data بدون توقف حافظه را دوباره بالا می‌برد

پارس جریانی فقط سمت خواندن را مهار می‌کند. اگر سمت نوشتن فشار معکوس را نپذیرد، حافظه دوباره بالا می‌رود. شکست کلاسیک: نوشتن غیرهمزمان درون handler رویداد data بدون توجه به بافر writable:

// نادرست: رویداد data + نوشتن غیرهمزمان، فشار معکوس کاملاً از دست می‌رود
readable.on('data', async (chunk) => {
  await slowWrite(chunk); // استریم منتظر نمی‌ماند؛ بافر مدام متورم می‌شود
});

در حالت data استریم همچنان جاری است، هرچقدر هم slowWrite کند باشد، و همه‌چیز در بافر داخلی writable تلنبار می‌شود. روی همان نمونه ۱۸۶ مگابایتی، رکوردها را به یک Writable کند فرستادیم که در هر صدمین بلوک ۱ میلی‌ثانیه تأخیر می‌کند. با نادیده‌گرفتن فشار معکوس اوج RSS به ۴۰۷ مگابایت رسید؛ با توقف از طریق await once(sink, 'drain') وقتی write() مقدار false می‌دهد، ۱۶۱ مگابایت. تفاوت ۲۴۶ مگابایتی literally داده‌هایی است که در بافر نوشتن نشسته‌اند.

// درست: وقتی write() false می‌دهد توقف، ادامه پس از drain
for await (const { value } of pipeline) {
  if (!sink.write(value)) {
    await once(sink, 'drain');
  }
}

دو توصیه میدانی دیگر: هنگام سرهم‌کردن دستی زنجیره استریم‌ها، highWaterMark را برای هر استریم صریحاً تعیین کنید — مقدار پیش‌فرض ۱۶ در objectMode برای اشیای بزرگ بیش از حد است؛ و pipeline() از stream/promises را به pipe() ترجیح دهید که انتشار خطا و پاکسازی را بر عهده می‌گیرد.

اندازه‌گیری‌ها: اوج حافظه چهار راهبرد

راهبرد نمونه اوج RSS مدت کاربرد
readFileSync + JSON.parse 186MB / 480 هزار 612MB 1.3s فایل‌های کوچک، دسترسی تصادفی
streamArray + for await + نوشتن کند در دیتابیس (هر یک 0.5ms) همان 104MB (صاف) به‌ریتم دیتابیس ورود رکوردبه‌رکورد، تبدیل
streamArray + نوشتن با data، بدون فشار معکوس همان 407MB ~10s نمونه نادرست
streamArray + write()/drain همان 161MB ~10s نوشتن روی دیسک یا ارسال به پایین‌دست

محیط: Node 22.13، Maximum resident set size از /usr/bin/time -v، نمونه سنتتیک با فیلدهای شبیه کسب‌وکار، اجراهای تکی بدون میانگین‌گیری، شبیه‌سازی نوشتن کند با setTimeout. این اعداد نتیجه مرتبه بزرگی برای این نمونه‌اند نه ثابت‌های جهانی — با داده خودتان اندازه بگیرید.

دو عدد شایان توجه‌اند. راهبرد اول و دوم شش برابر در حافظه تفاوت دارند، به بهای مبادله «۱.۳ ثانیه» با «سرعت دیتابیس». سوم و چهارم ۲.۵ برابر تفاوت دارند: خواندن جریانی بدون فشار معکوس در نوشتن تنها نیمی از مسئله را حل می‌کند.

عیب‌یابی: اطمینان از اینکه فشار معکوس واقعاً کار می‌کند

مسائل حافظه در پروداکشن با حدس حل نمی‌شوند. مقاله Tencent Cloud درباره عیب‌یابی فشار معکوس روشی عملی می‌دهد:

  1. موقتاً رویدادهای 'pause' و 'resume' را روی استریم‌های حساس لاگ کنید. اگر خط‌لوله پرترافیک هرگز pause نشود، جایی داده در حافظه انبار می‌شود؛
  2. writable.writableLength را رصد کنید — رشد پیوسته یعنی بافر هرگز خالی نمی‌شود؛
  3. RSS را با process.memoryUsage() در فواصل زمانی نمونه‌برداری و منحنی بکشید، «رشد شیبی» (انباشت) را از «ثبات اره‌ای» (آزادسازی سالم) جدا کنید.

زیر معنای for await رویدادهای pause و resume باید یکی‌درمیان رخ دهند؛ اگر هرگز نشعرند، دنبال listener اضافی data یا await فراموش‌شده بگردید.

چه زمانی جریان‌دهی پاسخ نیست

جریان‌دهی پاسخ پیش‌فرض نیست. برای فایل‌های چند ده مگابایتی با دسترسی تصادفی با کلید، یک فراخوانی ساده JSON.parse ساده‌تر و ارزان‌تر است. بازکردن فایل بزرگ در مرورگر قلمرو دیگری از مسئله است — چگونه فایل JSON بزرگ را باز کنیم نردبان ابزارهای نمایش را می‌پوشاند. مرزهای پارس جریانی روشن است:

  • سطح بالا آرایه است (یا داده‌ها به‌صورت JSONL بخش‌پذیرند)، مصرف ترتیبی است و نیازی به نگاه به عقب نیست؛
  • اندازه فایل کنترل‌نشده است یا به‌مراتب از حاشیه heap بزرگ‌تر است، و یک واردات نباید ردپای فرایند را دوبرابر کند؛
  • مصرف‌کننده اختلاف سرعت طبیعی دارد (نوشتن در دیتابیس، فراخوانی API پایین‌دست)، پس فشار معکوس لازم است نه شلنگ تمام‌قدرت.

وقتی شکل سطح بالا نامنظم است، نخست ساختار را در ابزار پارسر و قالب‌دهنده JSON ببینید؛ معادل خط فرمان در jq برای JSON بزرگ پوشش داده شده — jq --stream و streamArray یک ایده‌اند در دو زمان‌اجرا.

پرسش‌های متداول

stream-json چقدر از JSON.parse کندتر است؟

در پارس خالص JSON.parse برنده است: ۱.۳ ثانیه برای نمونه ۱۸۶ مگابایتی در برابر حدود ۷ ثانیه streamArray بدون تأخیر نوشتن (پارس توکنی به‌علاوه ساخت شی رکوردبه‌رکورد). سود جریان‌دهی تماماً در سمت حافظه است: اوج از ۶۱۲ به ۱۰۴ مگابایت می‌رسد. واردات به‌هرحال محدود به نوشتن دیتابیس است، پس پرداخت چند ثانیه پارس اضافه در ازای حاشیه حافظه شش‌برابر معمولاً معامله خوبی است؛ درون پاسخ‌های API میلی‌ثانیه‌ای، نه.

آیا فشار معکوس for await همان pause/resume دستی است؟

از نظر معنایی بله: for await استریم خواندنی را تا معلق‌بودن بدنه حلقه متوقف نگه می‌دارد، معادل فراخوانی pause() وقتی write() false می‌دهد و resume() هنگام drain. تفاوت: سازوکار زبان دفترداری را خودش انجام می‌دهد و چیزی جا نمی‌ماند؛ سیم‌کشی دستی با یک جای از قلم افتاده فشار معکوس تمام زنجیره را از دست می‌دهد.

اگر سطح بالا یک شیء غول‌آسا باشد نه آرایه چه؟

stream-json عرضه‌کننده streamObject() (صادر به‌ازای هر کلید) و فیلتر Pick (فقط زیردرخت انتخابی را پارس می‌کند) است. اگر چند فیلد کافی است، Pick با JSONPath کل گراف را به زیرگراف لازم می‌کاهد. ورودی چندسندی (JSON Lines، توالی‌های JSON) بهتر است خط‌به‌خط شکسته و به‌عنوان سندهای مستقل پردازش شود.

چگونه نتیجه را به‌صورت JSONL بنویسیم یا به پایین‌دست بفرستیم؟

سمت نوشتن همان پرسش فشار معکوس است: fs.createWriteStream و http.request هر دو نیازمند بررسی مقدار بازگشتی write() و انتظار once(stream, 'drain') در صورت false هستند — یا writable را به pipeline() وصل کنید. تأیید ساده است: منحنی RSS پس از یک اجرا باید پایدار باشد و writableLength نباید پیوسته رشد کند.

سریع‌ترین پایش حافظه برای یک کار واردات چیست؟

نسخه حداقلی: تایمری که هر ۱۰۰ میلی‌ثانیه process.memoryUsage().rss را در آرایه نمونه‌برداری و در پایان بیشینه را چاپ می‌کند. دقیق‌تر: /usr/bin/time -v node task.js مستقیماً Maximum resident set size می‌دهد. در کانتینرها خط هشدار را روی ۷۰٪ حد حافظه بگذارید تا برای GC جا بماند.

منابع

ابزارهای مرتبط

مقالات مرتبط

jq و فایل‌های JSON بزرگ: چرا -s حافظه را منفجر می‌کند و چگونه به‌صورت استریمی پردازش کنیم

تجمیع چند صد مگابایت لاگ JSON با jq -s به OOM ختم می‌شود، در حالی که reduce inputs همان آمار را تنها با چند مگابایت RAM تولید می‌کند. اندازه‌گیری روی نمونه ۲۲۰ مگابایت و ۲ میلیون خط: slurp به ۲,۰۸ گیگابایت می‌رسد در برابر ۳,۵ مگابایت برای reducer استریمی. این مقاله سازوکار مصرف حافظه، پردازش خط‌به‌خط JSONL، رویدادهای مسیر --stream و سه دام واقعی، از جمله خروجی خالی بی‌صدای -n --stream را توضیح می‌دهد.

پیشرفتهحدود 6 دقیقه مطالعهبه‌روزرسانی 2026-11-12

دفتر حافظه JSON: رشته‌ها، اشیا و آرایه‌های بزرگ واقعاً چه هزینه‌ای دارند

فایل JSON ده مگابایتی می‌تواند در heap V8 به ۳۰ تا ۵۰ مگابایت تبدیل شود. بیاموزید رشته‌ها، اشیا و عددها واقعاً چه هزینه‌ای دارند، چگونه با process.memoryUsage خط پایه بگیرید و جریان چه زمانی کمک می‌کند.

پیشرفتهحدود 11 دقیقه مطالعهبه‌روزرسانی 2026-10-31

فایل بزرگ JSON باز نمی‌شود؟ ابزار مناسب را بر اساس حجم انتخاب کنید

خروجی‌های JSON چند ده مگابایتی اغلب ویرایشگرهای متنی و ابزارهای آنلاین را قفل می‌کنند، حال آنکه خود پارس تنها چند صد میلی‌ثانیه طول می‌کشد. ما زمان و حافظه هر مرحله را روی نمونه‌ای ۴۵ مگابایتی با ۵۰۰ هزار رکورد اندازه گرفتیم، نشان دادیم هزینه واقعی در تعداد خطوط و گره‌هاست و جدول انتخاب ابزار بر اساس حجم فایل ارائه کردیم: مشاهده آنلاین، استخراج خط فرمانی، پردازش جریانی و برنامه دسکتاپ.

متوسطحدود 6 دقیقه مطالعهبه‌روزرسانی 2026-11-07