Node.js में बड़ी JSON पढ़ना: stream-json से स्ट्रीमिंग पार्सिंग और बैकप्रेशर व्यवहार में
मुख्य बात: readFileSync और JSON.parse से 186MB JSON अरे पढ़ने पर मेमरी 612MB की चोटी तक पहुँचती है; stream-json के streamArray पर स्विच करने से वह 104MB पर समतल रहती है। यह लेख चार पढ़ने की रणनीतियों की माप के साथ तुलना करता है, बताता है कि for await बैकप्रेशर क्यों स्वाभाविक रूप से देता है, data इवेंट उसे कैसे खोता है, और लेखन पक्ष पर highWaterMark व drain कैसे सेट करें।

जब 186MB की JSON फाइल इंपोर्ट करने से प्रोसेस 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, जिसमें फील्ड में स्ट्रिंग, नेस्टेड ऑब्जेक्ट और अरे हैं, वास्तविक व्यापारिक संरचना की नकल करते हुए। /usr/bin/time -v से मापी गई Maximum resident set size की चोटी: फाइल 1.3 सेकंड में पढ़ी जाती है, पर RSS 612MB तक जाता है — फाइल का 3.3 गुणा। V8 के डिफ़ॉल्ट old space लिमिट 1.4–2GB पर, ऐसे कुछ काम समांतर में चलना ही काफी है कि कंटेनर OOM Kill का शिकार हो जाए।
हिसाब विलक्षण नहीं है: कच्चा टेक्स्ट मेमरी में एक प्रति घेरता है (लगभग 186MB), parse के बाद ऑब्जेक्ट ग्राफ दूसरी प्रति घेरता है (हर स्ट्रिंग की, हर नेस्टेड ऑब्जेक्ट के हेडर और हर अरे की अतिरिक्त लागत), और पार्सिंग प्रक्रिया खुद ऊपर क्षणिक आवंटन करती है। 600MB चोटी तक पहुँचना सामान्य है।
दूसरा कारण: JSON.parse पूरा टेक्स्ट पूरे ग्राफ से बदलता है
JSON.parse का ठेका: «मुझे पूरा टेक्स्ट दो — तुम्हें पूरा ग्राफ मिलेगा»। यह शुरू करने से पहले पूरे टेक्स्ट के तैयार रहने की माँग करता है और नतीजा खत्म होने पर ही सौंपता है। «पहले ये 1,000 रिकॉर्ड लो» जैसा कोई तंत्र मौजूद नहीं है।
ऑब्जेक्ट ग्राफ की लागत JSON की मेमरी हिसाब में प्रति मद मापी गई है: हर स्ट्रिंग वास्तविक जगह घेरती है, हर ऑब्जेक्ट की एक स्लॉट घेरती है, और अरे की चौड़ाई तत्वों के प्रकार पर निर्भर करती है। कुछ दर्जन MB 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);
}
}
उसी 186MB फाइल पर उन्हीं 480,000 रिकॉर्ड पर इस संस्करण की चोटी RSS 104MB है, पूरी अवधि में सपाट। मेमरी में हर क्षण सिर्फ «वर्तमान तत्व + पार्सर की स्थिति» मौजूद है; पूरे हुए रिकॉर्ड तुरंत वापस लिए जाते हैं।
एक बात भूलने में आसान है: for await पार्सर से अगला रिकॉर्ड तब तक नहीं खींचता जब तक saveToDb पूरा नहीं हो जाता, इसलिए पार्सर फाइल पढ़ना रोक देता है। डेटाबेस धीमा, पढ़ना धीमा — यही बैकप्रेशर है, स्वाभाविक रूप से बना, बिना एक भी अतिरिक्त कोड पंक्ति। dev.to पर 4GB नगर परिवहन फीड के अंतर्ग्रहण की समीक्षा वही श्रृंखला pick({filter:'data'}) के साथ उपयोग करती है और समान सपाट मेमरी वक्र रिपोर्ट करती है।
जब लेखन पक्ष टूटता है: न रुकने वाला data इवेंट मेमरी फिर ऊपर ले जाता है
स्ट्रीमिंग पार्सिंग सिर्फ पढ़ने के पक्ष को अनुशासित करता है। अगर लेखन बैकप्रेशर स्वीकार नहीं करता, मेमरी फिर बढ़ती है। क्लासिक विफलता: data हैंडलर के अंदर असिंक्रोनस लेखन, बिना writable के बफर की परवाह:
// गलत: data इवेंट + असिंक्रोनस लेखन, बैकप्रेशर पूरी तरह खो जाता है
readable.on('data', async (chunk) => {
await slowWrite(chunk); // stream इंतज़ार नहीं करता; बफर बढ़ता जाता है
});
data मोड में stream बहता रहता है, slowWrite कितना भी धीमा हो, और सब कुछ writable के भीतरी बफर में जमा होता है। उसी 186MB नमूने पर हमने रिकॉर्ड को एक धीमे Writable में भेजा जो हर सौवें chunk पर 1ms देरी करता है। बैकप्रेशर की अवहेलना करते हुए चोटी RSS 407MB तक गई; write() false लौटाते ही await once(sink, 'drain') से रोकते हुए — 161MB। 246MB का अंतर शब्दशः वह डेटा है जो लेखन बफर में बैठा है।
// सही: write() false लौटाए तो रोकें, drain पर जारी रखें
for await (const { value } of pipeline) {
if (!sink.write(value)) {
await once(sink, 'drain');
}
}
दो और मैदानी टिप्पणियाँ: stream श्रृंखला हाथ से जोड़ते समय हर stream पर highWaterMark स्पष्ट रूप से सेट करें — objectMode में डिफ़ॉल्ट 16 बड़े ऑब्जेक्ट के लिए अत्यधिक उदार है; और pipe() की जगह stream/promises का pipeline() पसंद करें, जो त्रुटि प्रसार और सफाई सँभाल लेता है।
माप: चार रणनीतियों की मेमरी चोटी
| रणनीति | नमूना | चोटी RSS | अवधि | उपयोग |
|---|---|---|---|---|
| readFileSync + JSON.parse | 186MB / 480 हज़ार | 612MB | 1.3s | छोटी फाइलें, यादृच्छिक पहुँच |
| streamArray + for await + धीमा DB लेखन (हर एक 0.5ms) | वही | 104MB (सपाट) | DB की लय पर | रिकॉर्ड-दर-रिकॉर्ड अंतर्ग्रहण, रूपांतरण |
| streamArray + data से लेखन, बैकप्रेशर बिना | वही | 407MB | ~10s | बुरा उदाहरण |
| streamArray + write()/drain | वही | 161MB | ~10s | डिस्क पर लिखना या आगे भेजना |
परिवेश: Node 22.13, /usr/bin/time -v से Maximum resident set size, व्यावसायिक आकार के फील्ड वाला सिंथेटिक नमूना, बिना औसत के एकल रन, setTimeout से धीमे लेखन का अनुकरण। ये संख्याएँ इस नमूने के लिए परिमाण-कोटि के निष्कर्ष हैं, सार्वभौमिक स्थिरांक नहीं — अपने डेटा पर मापें।
दो रीडिंग ध्यान की हकदार हैं। पहली और दूसरी रणनीति मेमरी में छह गुना भिन्न हैं, «1.3 सेकंड» को «DB की गति» से बदलने की कीमत पर। तीसरी और चौथी 2.5 गुना भिन्न हैं: पढ़ना स्ट्रीमिंग हो लेखन बैकप्रेशर रहित हो तो आधा काम ही हल होता है।
निदान: पुष्टि करें कि बैकप्रेशर वाकई काम कर रहा है
प्रोडक्शन की मेमरी समस्याएँ अंतर्ज्ञान से हल नहीं होतीं। Tencent Cloud की बैकप्रेशर ट्रबलशूटिंग सामग्री व्यावहारिक योजना देती है:
- गंभीर स्ट्रीम पर अस्थायी रूप से
'pause'और'resume'इवेंट लॉग करें। अगर बड़ी मात्रा की पाइपलाइन कभी नहीं रुकती, कहीं न कहीं डेटा मेमरी में जम रहा है; writable.writableLengthदेखें — निरंतर वृद्धि का अर्थ है बफर कभी नहीं सूखता;process.memoryUsage()से बीच-बीच में RSS नमूना लें और वक्र बनाएँ, «ढाल वृद्धि» (संचय) और «दाँतेदार स्थिरता» (स्वस्थ मुक्ति) में भेद करें।
for await की शब्दावली में pause औ resume इवेंट बारी-बारी आने चाहिए; अगर कभी नहीं चलते, कोई फालतू data लिसनर या भूला हुआ await खोजें।
कब स्ट्रीमिंग उत्तर नहीं है
स्ट्रीमिंग डिफ़ॉल्ट उत्तर नहीं है। कुछ दर्जन MB की फाइलों में की अनुसार यादृच्छिक पहुँच चाहिए तो एक JSON.parse कॉल सरल और सस्ता है। ब्राउज़र में बड़ी फाइल खोलना दूसरा समस्या-क्षेत्र है — बड़ी JSON फाइल कैसे खोलें दर्शक-सीढ़ी को कवर करता है। स्ट्रीमिंग पार्सिंग की सीमाएँ साफ हैं:
- सबसे ऊपरी स्तर अरे है (या डेटा JSONL की तरह बँट सकता है), उपभोग क्रमिक है, पीछे देखने की ज़रूरत नहीं;
- फाइल आकार अनियंत्रित है या heap मार्जिन से बहुत आगे निकल गया है, और एक इंपोर्ट प्रोसेस के पैर का निशान दोगुना नहीं कर सकता;
- उपभोक्ता के पास स्वाभाविक गति-अंतर है (DB लेखन, धारा के नीचे API कॉल), इसलिए बैकप्रेशर चाहिए, पूरी शक्ति का नली नहीं।
जब ऊपरी स्तर की आकृति अनियमित हो, पहले JSON पार्सर और फॉर्मेटर उपकरण में संरचना देखें; कमांड-लाइन समकक्ष बड़े JSON के लिए jq में है — jq --stream और streamArray दो रनटाइम में एक ही विचार हैं।
FAQ
stream-json JSON.parse से कितना धीमा है?
शुद्ध पार्सिंग में JSON.parse जीतता है: 186MB नमूने के लिए 1.3 सेकंड, बनिस्बत लेखन-विलंब रहित streamArray के लगभग 7 सेकंड (टोकन पार्सिंग जमा रिकॉर्ड-दर-रिकॉर्ड ऑब्जेक्ट निर्माण)। स्ट्रीमिंग का लाभ पूरा मेमरी पक्ष में है: चोटी 612MB से गिरकर 104MB हो जाती है। इंपोर्ट में जाम किसी भी सूरत में DB लेखन पर है, इसलिए छह गुना मेमरी मार्जिन के बदले कुछ सेकंड अतिरिक्त पार्सिंग आमतौर पर सही सौदा है; मिलीसेकंड स्तर की API प्रतिक्रियाओं के भीतर, नहीं।
क्या for await का बैकप्रेशर मैन्युअल pause/resume जैसा ही है?
अर्थ में हाँ: for await लूप का शरीर लंबित रहने तक पठनीय स्ट्रीम को निलंबित रखता है, जो write() false लौटाते ही pause() कॉल करने और drain पर resume() करने के बराबर है। अंतर: भाषा की तंत्र लेखा-जोखा खुद सँभालती है और कुछ भूलती नहीं; हाथ की तार-बंदी एक जगह चूकते ही पूरी श्रृंखला का बैकप्रेशर खो देती है।
अगर सबसे ऊपरी स्तर अरे नहीं बल्कि एक विशाल ऑब्जेक्ट हो?
stream-json streamObject() (कुंजी-दर-कुंजी जारी) और Pick फिल्टर (केवल चुना हुआ उपवृक्ष पार्स) देता है। कुछ फील्ड ही चाहिए तो Pick और JSONPath से पूरा ग्राफ आवश्यक उपग्राफ में सिमट जाता है। बहु-दस्तावेज़ इनपुट (JSON Lines, JSON क्रम) पंक्ति-दर-पंक्ति तोड़कर स्वतंत्र दस्तावेज़ मानकर चलाना बेहतर है।
नतीजा JSONL के रूप में लिखना हो या धारा के नीचे भेजना हो तो?
लेखन पक्ष वही बैकप्रेशर प्रश्न है: fs.createWriteStream और http.request दोनों write() के लौटाए मान की जाँच माँगते हैं और false पर once(stream, 'drain') की प्रतीक्षा — या writable को pipeline() से जोड़ दें। जाँच सरल है: एक रन के बाद RSS वक्र स्थिर होना चाहिए और writableLength लगातार नहीं बढ़ना चाहिए।
इंपोर्ट काम के लिए सबसे तेज़ मेमरी मॉनिटर क्या है?
न्यूनतम संस्करण: एक टाइमर हर 100ms पर process.memoryUsage().rss को अरे में नमूना लेता है और अंत में अधिकतम छापता है। अधिक सटीक: /usr/bin/time -v node task.js सीधे Maximum resident set size देता है। कंटेनर में चेतावनी रेखा मेमरी सीमा के 70% पर रखें, GC के लिए जगह छोड़ते हुए।