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

כשייבוא של קובץ 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 נותן תוכנית מעשית:
- לוגו זמנית את האירועים
'pause'ו-'resume'על הזרמים הקריטיים. אם צינור בנפח גדול לעולם לא עוצר לרגע, אי-שם נתונים מצטברים בזיכרון; - עקבו אחרי
writable.writableLength— צמיחה מתמדת פירושה שהחוצץ אף פעם לא מתרוקן; - דגמו 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.