JSON Toolkit

קריאת JSON גדול ב-Node.js: ניתוח סטרימינג עם stream-json ו-Backpressure בפועל

שורה תחתונה: קריאת מערך JSON של 186MB עם readFileSync ו-JSON.parse מדחפת את הזיכרון לשיא של 612MB; מעבר ל-streamArray של stream-json שומר על העקומה שטוחה ב-104MB. המאמר משווה ארבע אסטרטגיות קריאה לפי מדידות, מסביר מדוע for await מייצר backpressure באופן טבעי, כיצד אירוע ה-data מאבד אותו, וכיצד להגדיר highWaterMark ו-drain בצד הכתיבה.

בינייםכ-5 דקות קריאהפורסם 2026-11-17עודכן 2026-11-17
סטרימינג של קובץ JSON גדול ב-Node.js: השוואת streamArray ו-backpressure

כשייבוא של קובץ JSON בן 186MB מדחיף את התהליך ל-600MB של זיכרון, האשם אינו גודל הקובץ — JSON.parse החליף את כל הטקסט בכל גרף האובייקטים במכה אחת. החליפו את אסטרטגיית הקריאה ועקומת הזיכרון תתיישר.

סימפטום אחד: קובץ 186MB עם שיא של 612MB

משימות ייבוא בצד השרת הן האזור העיקרי לבעיה זו: סנכרוני הזמנות מתוכננים, ניקוי לוגים, טעינת היסטוריה בכמות. מימוש טיפוסי נראה כך:

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. הדגימה: מערך של 480,000 רשומות הזמנות, קובץ 186MB עם מחרוזות, אובייקטים מקוננים ומערכים בשדות, בחיקוי מבנה עסקי אמיתי. שיא ה-Maximum resident set size שנמדד עם /usr/bin/time -v: הקובץ נקרא ב-1.3 שניות, אבל ה-RSS מגיע ל-612MB — פי 3.3 מהקובץ. עם גבול ברירת המחדל של ה-old space של V8 ב-1.4–2GB, מספר משימות כאלה במקביל מספיק כדי שהקונטיינר יסיים כ-OME Kill.

החשבון אינו אקזוטי: הטקסט הגולמי תופס עותק אחד בזיכרון (כ-186MB), גרף האובייקטים אחרי ה-parse תופס עותק שני (כל מפתח מחרוזת, כל כותרת של אובייקט מקונן וכל מערך נושאים עלות), ותהליך הניתוח עצמו מקצה זמנית מעל זה. הגעה לשיא של 600MB היא נורמה.

הסיבה השנייה: JSON.parse מחליף את כל הטקסט בכל הגרף

החוזה של JSON.parse: «תן לי את הטקסט המלא — תקבל את הגרף המלא». הוא דורש שכל הטקסט יהיה במקום לפני ההתחלה ומוסר את התוצאה רק בסיום. לא קיים מנגנון של «הנה קודם 1,000 הרשומות הראשונות».

עלות גרף האובייקטים נמדדה סעיף סעיף במאמר חשבון הזיכרון של JSON: כל מחרוזת תופסת מקום אמיתי, כל מפתח אובייקט תופס תא, ורוחב מערך נקבע לפי סוגי האיברים. כמה תריסר MB של JSON הופכים באופן שגרתי לשלושה-חמישה פעמים גדולים יותר אחרי ניתוח, כשהשיא נוסף מעל.

אבל לרוב משימות הייבוא כלל אין צורך בגרף המלא: להכניס שורה-שורה, לסנן שורה-שורה, להמיר שורה-שורה — כל רשומה יכולה להשתחרר מיד אחרי העיבוד. מה שהמשימה צריכה הוא היכולת «ניתחתי רשומה — מסרתי רשומה». זה בדיוק ההגדרה של ניתוח סטרימינג.

הפתרון: streamArray מספק רשומה-רשומה, ו-for await נותן backpressure בחינם

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

על אותו קובץ 186MB עם אותן 480,000 רשומות, לגרסה הזו שיא RSS של 104MB, שטוח לאורך כל הריצה. בזיכרון קיימים בכל רגע רק «האיבר הנוכחי + מצב המנתח»; רשומות שהסתיימו נגאלות מיד.

פרט קל לפספוס: for await לא מושך את הרשומה הבאה מהמנתח עד ש-saveToDb מסתיים, ולכן המנתח מפסיק לקרוא את הקובץ. מסד נתונים איטי יותר, קריאה איטית יותר — זהו backpressure, נוצר טבעי, בלי אפילו שורת קוד נוספת. סקירה ב-dev.to על קליטת פיד תחבורה עירוני בן 4GB משתמשת בשרשרת זהה עם pick({filter:'data'}) ומדווח על עקומת זיכרון שטוחה באותה מידה.

כשצד הכתיבה נופל: אירוע data ללא השהיה מדחיף את הזיכרון בחזרה

ניתוח סטרימינג ממשמע רק את צד הקריאה. אם הכתיבה לא מקבלת backpressure, הזיכרון עולה שוב. הכשל הקלאסי: כתיבה אסינכרונית בתוך מטפל data בלי להתייחס לחוצץ של ה-writable:

// שגוי: אירוע data + כתיבה אסינכרונית, backpressure אובד לחלוטין
readable.on('data', async (chunk) => {
  await slowWrite(chunk); // הזרם לא ממתין; החוצץ ממשיך להתנפח
});

במצב data הזרם ממשיך לזרום, כמה ש-slowWrite איטי, והכל מצטבר בחוצץ הפנימי של ה-writable. על אותה דגימה של 186MB הפנינו את הרשומות ל-Writable איטי שמעכב 1ms בכל צ'אנק מאה. בלי טיפול ב-backpressure שיא ה-RSS הגיע ל-407MB; עם השהיה באמצעות await once(sink, 'drain') כש-write() מחזיר false — 161MB. ההפרש של 246MB הוא מילולית נתונים יושבים בחוצץ הכתיבה.

// נכון: השהיה כש-write() מחזיר false, המשך ב-drain
for await (const { value } of pipeline) {
  if (!sink.write(value)) {
    await once(sink, 'drain');
  }
}

עוד שתי הערות שטח: בעת הרכבת שרשרת זרמים ביד, הגדירו highWaterMark במפורש על כל זרם — ברירת המחדל של 16 ב-objectMode נדיבה מדי לאובייקטים גדולים; והעדיפו את pipeline() מ-stream/promises במקום pipe(), שלוקח על עצמו הפצת שגיאות וניקוי.

המדידות: שיא זיכרון של ארבע אסטרטגיות

אסטרטגיה דגימה שיא RSS משך שימוש
readFileSync + JSON.parse 186MB / 480 אלף 612MB 1.3s קבצים קטנים, גישה אקראית
streamArray + for await + כתיבת DB איטית (0.5ms כל אחת) זהה 104MB (שטוח) לפי הקצב של ה-DB קליטה רשומה-רשומה, טרנספורמציות
streamArray + כתיבה ב-data, ללא backpressure זהה 407MB ~10s הדוגמה שלא לחקות
streamArray + write()/drain זהה 161MB ~10s כתיבה לדיסק או העברה הלאה

סביבה: Node 22.13, Maximum resident set size דרך /usr/bin/time -v, דגימה סינתטית עם שדות בצורה עסקית, ריצות בודדות בלי ממוצע, דימוי כתיבה איטית באמצעות setTimeout. המספרים האלה הם מסקנות סדר גודל לדגימה הזו, לא קבועים אוניברסליים — מדדו על הנתונים שלכם.

שתי קריאות ראויות לתשומת לב. האסטרטגיה הראשונה והשנייה שונות פי שישה בזיכרון, במחיר החלפת «1.3 שניות» ב«מהירות ה-DB». השלישית והרביעית שונות פי 2.5: קריאה סטרימינג בלי backpressure בכתיבה פותרת רק חצי מהעבודה.

אבחון: לוודא שה-backpressure באמת עובד

בעיות זיכרון בפרודקשן לא נפתרות באינטואיציה. חומר של Tencent Cloud על איתור תקלות backpressure נותן תוכנית מעשית:

  1. לוגו זמנית את האירועים 'pause' ו-'resume' על הזרמים הקריטיים. אם צינור בנפח גדול לעולם לא עוצר לרגע, אי-שם נתונים מצטברים בזיכרון;
  2. עקבו אחרי writable.writableLength — צמיחה מתמדת פירושה שהחוצץ אף פעם לא מתרוקן;
  3. דגמו RSS עם process.memoryUsage() לפי מרווחים וציירו את העקומה, תוך הפרדה בין «צמיחה במדרון» (צבירה) ל«יציבות משוננת» (שחרור בריא).

תחת הסמנטיקה של for await, אירועי pause ו-resume חייבים להתחלף; אם הם לא נורים אף פעם, חפשו מאזין data מיותר או await שנשכח.

מתי סטרימינג אינו התשובה

סטרימינג אינו התשובה כברירת מחדל. לקבצים של כמה תריסר MB עם גישה אקראית לפי מפתח, קריאת JSON.parse אחת פשוטה וזולה יותר. פתיחת קובץ גדול בדפדפן היא תחום בעיה אחר — איך לפתוח קובץ JSON גדול עוסק בסולם המציגים. גבולות ניתוח הסטרימינג ברורים:

  • הרמה העליונה היא מערך (או שהנתונים ניתנים לפיצול כ-JSONL), הצריכה סדרתית, בלי הבטות לאחור;
  • גודל הקובץ בלתי נשלט או חורג בהרבה ממרחב ה-heap, וייבוא אחד לא אמור להכפיל את טביעת הרגל של התהליך;
  • לצרכן יש פער מהירות טבעי (כתיבה ל-DB, קריאות API במורד הזרם), ולכן נדרש backpressure, לא צינור בעוצמה מלאה.

כשצורת הרמה העליונה אינה סדירה, הציצו קודם למבנה בכלי מנתח ומעצב JSON; המקבילה בשורת הפקודה מכוסה ב jq ל-JSON גדול — jq --stream ו-streamArray הם אותה רעיון בשני רנטיים.

שאלות נפוצות

כמה stream-json איטי מ-JSON.parse?

בניתוח טהור JSON.parse מנצח: 1.3 שניות לדגימה של 186MB מול כ-7 שניות של streamArray בלי השהיית כתיבה (ניתוח טוקנים ועוד בניית אובייקטים רשומה-רשומה). הרווח של הסטרימינג כולו בצד הזיכרון: השיא צונח מ-612MB ל-104MB. ייבוא מוגבל בכתיבה ל-DB ממילא, אז לשלם כמה שניות ניתוח בתמורה למרווח זיכרון פי שישה בדרך כלל עסקה טובה; בתוך תשובות API ברמת מילישניות — לא.

האם ה-backpressure של for await זהה ל-pause/resume ידניים?

סמנטית כן: for await משהה את הזרם הקריא כל עוד גוף הלולאה תלוי, שווה ערך לקריאת pause() כש-write() מחזיר false ו-resume() ב-drain. ההבדל: מנגנון השפה מנהל את ההנהלת חשבונות ולא שוכח דבר; חיווט ידני מאבד את ה-backpressure של השרשרת כולה ברגע שנקודה אחת חמקה.

מה אם הרמה העליונה היא אובייקט ענק אחד?

stream-json מספק את streamObject() (פולט לפי מפתח) ואת מסנן Pick (מנתח רק את תת-העץ הנבחר). אם מספיקים כמה שדות, Pick עם JSONPath מצמק את כל הגרף לתת-הגרף הנדרש. קלט מרובה מסמכים (JSON Lines, רצפי JSON) עדיף לפצל שורה-שורה ולעבד כמסמכים עצמאיים.

איך לכתוב את התוצאה כ-JSONL או להעביר הלאה במורד הזרם?

צד הכתיבה הוא אותה שאלת backpressure: fs.createWriteStream ו-http.request מחייבות בדיקת ערך ההחזר של write() והמתנה ל-once(stream, 'drain') כש-false — או חברו את ה-writable אל pipeline(). האימות פשוט: עקומת ה-RSS אחרי ריצה אחת צריכה להיות יציבה ו-writableLength לא אמור לצמוח באופן מתמשך.

מהי מערכת ניטור הזיכרון המהירה ביותר למשימת ייבוא?

גרסה מינימלית: טיימר שדוגם process.memoryUsage().rss כל 100ms למערך ומדפיס את המקסימום בסוף. מדויק יותר: /usr/bin/time -v node task.js נותן ישירות את ה-Maximum resident set size. בקונטיינרים, הציבו את קו האזעקה ב-70% מגבול הזיכרון, תוך השארת מרווח ל-GC.

מקורות

כלים מתאימים

מאמרים קשורים

jq וקבצי JSON גדולים: מדוע ‎-s‎ מפוצץ זיכרון וכיצד לעבד בסטרימינג

צבירת מאות מגהבייט של לוגים בפורמט JSON עם jq -s מסתיימת ב־OOM, בעוד ש־reduce inputs מייצר את אותה סטטיסטיקה בכמה מגהבייטים בלבד של זיכרון RAM. נמדד על דגימה של 220MB ושני מיליון שורות: slurp מגיע ל־2.08GB מול 3.5MB למפחית הסטרימינג. המאמר מסביר את מנגנון צריכת הזיכרון, את העיבוד שורה־שורה של JSONL, את אירועי הנתיב של ‎--stream‎ ושלוש מלכודות אמיתיות, כולל הפלט הריק השקט של ‎-n --stream.

מתקדםכ-6 דקות קריאהעודכן 2026-11-12

קובץ JSON גדול לא נפתח? בחרו את הכלי הנכון לפי הגודל

ייצוא JSON בגודל עשרות MB נוטה להקפיא עורכי טקסט וכלים מקוונים, בעוד שהפענוח עצמו לוקח רק כמה מאות אלפיות שנייה. מדדנו זמן וזיכרון בכל שלב עבור דגימה של 45 MB עם 500,000 רשומות, הראינו שהעלות האמיתית נמצאת במספר השורות והצמתים, ובנינו טבלת בחירת כלים לפי גודל הקובץ: צפייה מקוונת, שורת פקודה, עיבוד זרימה ואפליקציית דסקטופ.

בינוניכ-6 דקות קריאהעודכן 2026-11-07