JSON Toolkit

वह JSON जो अभी पूरा नहीं आया, उसे कैसे पार्स करें: स्ट्रीमिंग प्रीव्यू और इंक्रीमेंटल रिपेयर

मुख्य बात: LLM टोकन दर टोकन JSON उगलते हैं और API बड़े रिस्पॉन्स चंक दर चंक भेजते हैं, पर JSON.parse तब तक काम शुरू नहीं करता जब तक पूरा डॉक्युमेंट न आ जाए। यह लेख तीन तरह के क्रियान्वयन को अलग करता है — पूर्ण रिपेयर, सच्चा इंक्रीमेंट और आंशिक पार्सिंग — और बताता है कि Allow मास्क प्रीव्यू को स्थिर कैसे रखता है, पाइपलाइन की माप और प्रोडक्शन-रेडी कोड सहित।

मध्यम स्तर~5 मिनट पढ़ें2026-11-16 को प्रकाशित2026-11-16 को अपडेट किया गया
स्ट्रीमिंग JSON के चंक्स पर आंशिक पार्सिंग और इंक्रीमेंटल रिपेयर का आरेख

JSON.parse का ठेका है «पूरा डॉक्युमेंट आने तक शुरू नहीं होंगा», जबकि स्ट्रीमिंग का ठेका है «एक चंक आएगा तो उसी को संभालूँगा» — दोनों का टकराव स्पीड में नहीं, पूर्णता के सिमेंटिक्स में है: जो डॉक्युमेंट अभी लिखा ही नहीं गया, उसका कोई «सही पार्स परिणाम» होता ही नहीं।

लक्षण: तीन सीन जहाँ पूरे टेक्स्ट का इंतज़ार नहीं हो सकता

पहला सीन LLM ऐप है। मॉडल टोकन दर टोकन JSON उगलता है; 8KB का स्ट्रक्चर्ड आउटपुट आने में दर्जनों सेकंड लग सकते हैं, और यूज़र खाली पैनल ताकता रह जाता है — जबकि पहले फ़ील्ड्स पहले सेकंड में ही दिखाए जा सकते थे। दूसरा सीन गेटवे और प्रॉक्सी हैं: अपस्ट्रीम कई दर्जन MB का रिस्पॉन्स HTTP चंक्स में धकेलता है, और जो प्रॉक्सी आगे भेजने से पहले फ़ील्ड फ़िल्टर करना चाहती है, res.json() से सब बफर कर ले तो उसकी मेमोरी का चोटी का उपयोग कई गुना बढ़ जाता है। तीसरा सीन मैसेज क्यू और लॉग पाइपलाइन हैं: NDJSON रिकॉर्ड एक के पीछे एक आते हैं, कंज्यूमर बैच इकट्ठा नहीं करना चाहता।

साझा बात साफ़ है: डेटा धीरे-धीरे आता है, जबकि स्टैंडर्ड पार्सर पूरा डॉक्युमेंट ही स्वीकार करता है। JSON.parse पहले चंक में ही Unexpected end of JSON input फेंकता है, 65वें चंक में भी वही एरर फेंकता है, और परिणाम सिर्फ़ आख़िरी चंक में देता है। इंतज़ार ही इकलौता रास्ता नहीं — पर आपको पहले तय करना होगा कि अधूरे डॉक्युमेंट का «पार्स» होना क्या माने।

प्रीफ़िक्स दर प्रीफ़िक्स पार्सिंग की मूल सिमेंटिक्स: हर चंक वैध है या नहीं

7847 बाइट का ऑर्डर ऐरे लें, 120 कैरेक्टर के चंक्स में काटकर स्ट्रीमिंग आगमन का सिम्युलेशन करें (Node v22.13.1, jsonrepair 3.15.0, partial-json 0.1.7), और हर प्रीफ़िक्स पर तीन पार्सर चलाएँ:

तरीका 66 प्रीफ़िक्स पर सफलता संचित समय सिमेंटिक्स
JSON.parse 1 (सिर्फ़ आख़िरी चंक) 2.1 ms सब या कुछ नहीं
partial-json (Allow.ALL) 66 (पहले चंक से ही) 14.3 ms हमेशा «अब तक ज्ञात» देता है
jsonrepair हर प्रीफ़िक्स पर पूर्ण रिपेयर दोबारा चलाना 66 23.8 ms ब्रैकेट पूरा करने पर पार्स करने योग्य, पर हर बार शुरुआत से गणना

दो निर्णायक निष्कर्ष। एक: JSON.parse की विफलता कोई जानकारी नहीं बहन करती — रिपोर्ट की गई जगह हमेशा अंत पर होती है, न आप जानते हैं कितना बाकी है, न ये कि मिला हुआ हिस्सा खुद संगत है या नहीं। दो: हर प्रीफ़िक्स पर पूर्ण रिपेयर दोबारा चलाना किया जा सकता है पर व्यावहारिक नहीं: हर कॉल में औसत टेक्स्ट लंबाई रैखिक गति से बढ़ती है, संचित लागत O(n²) गति से। 23.8 ms अपराधहीन लगता है; टेक्स्ट मेगाबाइट पैमाने पर जाते ही वही गुणक बर्बाद CPU सेकंड बन जाता है।

और ध्यान रखें: «प्रीफ़िक्स दर प्रीफ़िक्स पार्स होने योग्य» का मतलब «डेटा पूरा» नहीं। पूरे किए गए प्रीफ़िक्स की आख़िरी संख्या अगले चंक में आगे बढ़ सकती है, आख़िरी स्ट्रिंग escape सीक्वेंस के बीच कट सकती है — स्ट्रीमिंग प्रीव्यू की सारी अस्थिरता की जड़ यहीं है।

तीन तरह के क्रियान्वयन काम कैसे बाँटते हैं

स्ट्रीमिंग पक्ष की लाइब्रेरी तीन मुद्रा में बँटती हैं, और मुद्रा की गलत पसंद लाइब्रेरी की गलत पसंद से ज़्यादा नुकसान करती है:

लाइब्रेरी मुद्रा उपयुक्त अनुपयुक्त
jsonrepair (3.15.0) पूर्ण रिपेयर + Transform stream मिलता है «वह डॉक्युमेंट जो आख़िर में पूरा होगा», और बिना क्षति का परिणाम चाहिए सिर्फ़ प्रीव्यू (आउटपुट पूरा मरम्मत किया टेक्स्ट है, डेटा ऑब्जेक्ट नहीं)
partial-json (0.1.7) आंशिक पार्सिंग, अधूरी पूँछ फेंकने की इजाज़त UI प्रीव्यू: हर प्रीफ़िक्स तुरंत इस्तेमाल-लायक ऑब्जेक्ट देता है डेटाबेस में लिखना (प्रीव्यू में फ़ील्ड कम हो सकते हैं, संख्या अस्थिर)
jsonmend (0.1.3) सच्चा इंक्रीमेंट, सार्वजनिक कंसिस्टेंसी कॉर्पस «एक भाग घुसा, एक वर्ज़न निकला» शैली की पाइपलाइन, पुराना दोबारा स्कैन नहीं पहले ही खत्म हो चुका डॉक्युमेंट (पूर्ण पार्स तेज़)

ये तीन प्रतिद्वंद्वी नहीं। jsonrepair अपने ./stream सबपाथ से jsonrepairTransform निर्यात करता है, एक स्टैंडर्ड Transform stream: चंक्स बाएँ से घुसते हैं, दाएँ से मरम्मत किया JSON टेक्स्ट ब्लॉक निकलते हैं, और जोड़े जाने पर इनका योग पूरे टेक्स्ट के एक बार के पार्स के बिल्कुल बराबर होने की गारंटी — decode(encode(x)) === x की समता वह रखता है। partial-json दूसरी रेखा रखता है: हर प्रीफ़िक्स तुरंत ऑब्जेक्ट देता है, मुआवज़े में «अंतिम परिणाम नहीं बदलेगा» का वादा छोड़ देता है। jsonmend तीसरी रेखा को सार्वजनिक कंसिस्टेंसी कॉर्पस से बाँधता है: सच्चा इंक्रीमेंट, सिमेंटिक तुलना योग्य, दोनों तरफ के क्रियान्वयन एक ही रिग्रेशन आधार रखते हैं।

Allow मास्क: प्रीव्यू में कौन-से फ़ील्ड दिखाने की हिम्मत

partial-json की जड़ «जैसा भी टूटा इनपुट पार्स कर दूँगा» नहीं, बल्कि कॉलर खुद घोषित करता है कि वह अधूरेपन की कितनी डिग्री झेलेगा। मास्क JSON टाइप के अनुसार बिट से जुड़ता है (STR, NUM, ARR, OBJ…); एक टाइप हटा दें, उस टाइप के अधूरे मान प्रीव्यू में घुसते नहीं:

import { parse, Allow } from 'partial-json';

parse('{"price": 12', Allow.ALL);
// → { price: 12 }        संख्या 12 का मतलब «अब तक पढ़ा गया»
parse('{"price": 1234.5', Allow.ALL);
// → { price: 1234.5 }    वही फ़ील्ड बदल गया: प्रीव्यू अस्थिर
parse('{"price": 12', Allow.ALL & ~Allow.NUM);
// → {}                   NUM बिट हटाने पर अधूरी संख्या नहीं दिखती

माप में सबसे इंजीनियरिंग-मूल्यवान यही परिणाम है: दाम, काउंटर जैसी संख्याएँ जो अगले चंक में आगे बढ़ सकती हैं, UI पर हर फ्रेम बदलती हैं; और Allow.ALL & ~Allow.NUM उन्हें आदेश देता है चुपचाप लिखा जाना पूरा होने तक इंतज़ार करें। स्ट्रिंग भी वैसे ही — Unicode escape सीक्वेंस के बीच कटी स्ट्रिंग को partial-json 0.1.7 सुरक्षित फेंक देता है, अंदाज़ा लगाने के बजाय। प्रीव्यू की स्थिरता पार्सर का उपहार नहीं; कॉलर मास्क से उसे खरीदता है।

स्ट्रीमिंग रिपेयर के क्रियान्वयन की लागत: लुक-बैक बफर और वर्गीकृत कॉपी

स्ट्रीमिंग पाइपलाइन का मतलब पूरे API को for लूप में लपेट देना नहीं। वही 66-चंक नमूना लें, jsonrepairTransform पाइपलाइन कुल 6.7ms लेती है, जबकि हर प्रीफ़िक्स पर पूर्ण रिपेयर दोबारा चलाना संचित 23.8ms — 3.5 गुना का अंतर क्रियान्वयन परत से आता है: स्ट्रीमिंग क्रियान्वयन सिर्फ़ ज़रूरी विंडो में पीछे देखता है, आउटपुट इंक्रीमेंटल बफर से जोड़ता है, और पुराना टेक्स्ट बार-बार कॉपी नहीं करता।

jsonrepair की स्ट्रीमिंग कोर को HarmonyOS ArkTS में पोर्ट करने का अनुभव (openHarmony पर थर्ड-पार्टी लाइब्रेरी अनुकूलन) तीन ठोस लागत खोलता है: अपस्ट्रीम का streaming पथ «लुक-बैक बफर» जमा करता है, छोटे डॉक्युमेंट का नतीजा flush तक इंतज़ार करता है — लेखक ने इसलिए छोटे टेक्स्ट के लिए अलग IncrementalRepairer लिखा; अपस्ट्रीम का regular पथ आउटपुट पूरा बार-बार कॉपी करता है, जो वर्गीकृत स्वभाव का है, पोर्ट में OutputBuilder ने उसे हटाया; और एक बॉर्डर कैरेक्टर का जाल बचा है — «अंत तक पढ़ लिया» के परीक्षण के लिए text[i] === undefined की शर्त charAt में गए धोखा खा सकती है, क्योंकि ''.includes('') हमेशा true है, सीमा पार जाने को पहले खाली स्ट्रिंग से रोकना होगा। ये ब्योरे बताते हैं कि «स्ट्रीमिंग रिपेयर» क्यों अपनी श्रेणी की जगह पाने लायक है: उसकी इंजीनियरिंग जटिलता और एक-बार का रिपेयर एक पैमाने पर नहीं।

ज्ञात सीमा भी दर्ज करें: jsonrepair का issue #214 बताता है कि स्ट्रीमिंग रिपेयर slash-प्रीफ़िक्स्ड मान से पहले कॉमा के बिना वैध प्रीफ़िक्स को भी ठुकरा देता है — स्ट्रीमिंग मोड में लेक्सिकल स्तर पर «अगला कैरेक्टर अभी नहीं आया» और «इनपुट अवैध» में भेद करना कठिन है; लुक-बैक विंडो ही इस अस्पष्टता के लिए दिया गया दाम है।

कैसे उतारें: प्रीव्यू और स्टोरेज अलग रास्ते चलते हैं

ऊपर के सिमेंटिक्स को एक पाइपलाइन में गूँथें; सिद्धांत एक वाक्य में आ जाता है: प्रीव्यू आंशिक पार्सिंग से, स्टोरेज कठोर पार्सिंग से।

import { jsonrepairTransform } from 'jsonrepair/stream';
import { parse as partialParse, Allow } from 'partial-json';

// रास्ता 1: बिना क्षति की पाइपलाइन। घुसते: चंक्स, निकलते: मरम्मत किया JSON टेक्स्ट, आख़िर में कठोर सत्यापन
const tr = jsonrepairTransform();
tr.pipe(finalSink);                 // finalSink आगे JSON.parse + बिज़नेस सत्यापन करेगा
chunkStream.pipe(tr);

// रास्ता 2: प्रीव्यू पाइपलाइन। हर प्रीफ़िक्स एक UI फ्रेम देता है; अधूरी संख्याएँ और स्ट्रिंग मास्क रोकता है
function onChunk(buffer) {
  const preview = partialParse(buffer, Allow.ALL & ~Allow.NUM & ~Allow.STR);
  render(preview);                  // सिर्फ़ स्थिर फ़ील्ड बनाएँ; तेज़ बदलने वाले फ़ील्ड इंतज़ार करें
}

दो रास्तों का ठेका अलग है और एक दूसरे का प्रतिस्थापन नहीं: प्रीव्यू फ्रेम में फ़ील्ड कम हो सकते हैं, स्टोरेज फ्रेम में नहीं; स्टोरेज फ्रेम को स्ट्रीम खत्म होने तक इंतज़ार करना पड़ता है और पूरा JSON.parse बिज़नेस सत्यापन सहित पार करना पड़ता है, जबकि प्रीव्यू फ्रेम कभी कहीं लिखा ही नहीं जाता। अगर अपस्ट्रीम LLM का आउटपुट है, लिखने से पहले stop_reason से तय करना होगा कि काटा गया है या नहीं — «पहले stop_reason देखो, फिर रिपेयर की बात करो» वाला प्रवाह LLM का कटा JSON रिपेयर में विस्तृत है, यहाँ दोहराता नहीं।

कब स्ट्रीमिंग न करें

तीन वीटो शर्तें; एक भी पूरी हो तो ईमानदारी से पूर्ण पार्स ही लें: फ़ाइल छोटी — साधारण JSON.parse ~22MB तक एक बार में पढ़ते हैं आमतौर पर एक सेकंड से कम, स्ट्रीमिंग सिर्फ़ कोड बढ़ाती है; सिर्फ़ एक-बार की सांख्यिकी — एग्रीगेशन के लिए jq --stream या लाइन दर लाइन NDJSON सुविधाजनक, देखें JSONL प्रैक्टिकल गाइड; डाउनस्ट्रीम उपभोक्ता आंशिक डेटा स्वीकार नहीं करता — जैसे कुल रकम, प्रीव्यू से एक भी गलत गुणा हुआ मध्यवर्ती मान असली घाटा है; उस पल स्ट्रीमिंग प्रीव्यू की कीमत सिर्फ़ «प्रोग्रेस बार» बचती है।

स्ट्रीमिंग पार्सिंग जो हल करती है वह हमेशा «इंतज़ार नहीं हो सकता» है, «तेज़» नहीं। उतने ही टेक्स्ट पर पूर्ण पार्स की कुल CPU समय हर स्ट्रीमिंग विकल्प से कम है; आप लेना चाहते हैं पहले उपयोग-लायक बाइट तक का समय और निरंतर मेमोरी का जलस्तर। यह बदला लेन-देन साफ़ समझ लें, तकनीक का चुनाव डगमगाएगा नहीं।

अक्सर पूछे जाने वाले सवाल

प्रीव्यू ऑब्जेक्ट सीधे डेटाबेस में रख सकते हैं?

नहीं। प्रीव्यू «अब तक ज्ञात» की फोटो है: संख्या अगले चंक में आगे बढ़ सकती है, स्ट्रिंग कट सकती है, फ़ील्ड सामयिक रूप से गायब हो सकते हैं। लिखने से पहले स्ट्रीम खत्म होने तक इंतज़ार करके पूरे टेक्स्ट पर एक राउंड कठोर JSON.parse चलाना पड़ता है, फिर बिज़नेस सत्यापन पार करना पड़ता है। प्रीव्यू सिर्फ़ UI परत का है।

partial-json या jsonrepair?

आपको टेक्स्ट चाहिए या ऑब्जेक्ट, उस पर निर्भर। बिना क्षति का मरम्मत किया टेक्स्ट (डाउनस्ट्रीम पार्स कराने भेजने के लिए) — jsonrepair; उसका स्ट्रीमिंग आउटपुट पूरे पार्स से बराबर होने की गारंटी देता है। हर प्रीफ़िक्स का ऑब्जेक्ट तुरंत UI पर दिखाने के लिए — partial-json, Allow मास्क उस अस्थिरता के अनुसार सेट करें जितनी आप झेल सकते हैं।

स्ट्रीमिंग पार्सिंग क्या कुल समय घटाती है?

नहीं। पूर्ण पार्स की कुल CPU समय हमेशा सबसे कम, स्ट्रीमिंग विकल्प स्टेट रखरखाव की कीमत भी चुकाता है। स्ट्रीमिंग तीन चीज़ें बदलती है: पहले चंक के इस्तेमाल-लायक होने तक का समय, पूरी लंबाई अनुसार न बढ़ने वाली मेमोरी, और प्राप्ति के बीच प्रोसेस करने की क्षमता (आगे भेजना, फ़िल्टर, दिखाना)।

ऐरे के तत्व एक-एक कर आ रहे हैं, एक-एक कर संभालना चाहता हूँ?

वह दूसरा रास्ता है: stream-json का streamArray तत्व बंद होते ही {key, value} फेंकता है, और for await के साथ स्वाभाविक बैकप्रेशर बनता है — «पार्स कर के लिख» शैली के बल्क इंपोर्ट के लिए उपयुक्त; यह लेख पूरे डॉक्युमेंट पैमाने के प्रीव्यू की बात करता है।

संदर्भ

मेल खाते उपकरण

संबंधित लेख

JSON मरम्मत गाइड: टूटा LLM आउटपुट बिना भरोसे खोए बचाना

markdown फ़ेंस में लिपटे, अनुगामी कॉमा और Python लिटरल वाले LLM आउटपुट को सख़्त पार्सर पूरी तरह अस्वीकार करता है — बिना उद्धरण चिह्न के हाथ से संपादित कॉन्फ़िग भी। यह गाइड नौ तरह की त्रुटियों, जो मरम्मतकर्ता सच में ठीक करता है, और चार तरह की त्रुटियों, जो कभी नहीं ठीक करेगा, की वास्तविक सीमा खींचता है, समझाता है कि स्टेट मशीन regex क्यों हराती है, और jsonrepair व json-repair के साथ प्रोडक्शन-रेडी पार्स श्रृंखला देता है।

मध्यम~6 मिनट पढ़ें2026-11-08 को अपडेट किया गया

LLM का JSON बीच में कट जाए तो: पहले रुकने की वजह देखें, फिर मरम्मत की बात करें

मॉडल किसी मान के बीच में JSON काट देता है और पार्सर सिर्फ़ कॉलम नंबर देता है। ब्रैकेट बंद करने से वह फिर पार्स होने लगता है, पर तब हर खोया हुआ फ़ील्ड डेटा के अंदर छिप जाता है। यह लेख वह सीमा खींचता है कि ट्रंकेशन मरम्मत ईमानदारी से क्या लौटा सकती है और क्या दोबारा माँगना ही पड़ेगा।

व्यावहारिक~5 मिनट पढ़ें2026-11-14 को अपडेट किया गया

JSONL के साथ व्यावहारिक कार्य: खोलना, रूपांतरण और खराब लाइनों की पहचान

पूरी .jsonl फ़ाइल को JSON.parse को देकर त्रुटि पाना लगभग कभी यह नहीं दर्शाता कि फ़ाइल खराब है — यह दर्शाता है कि पढ़ने की रणनीति गलत है। यह मार्गदर्शिका JSONL की जाँच और लाइन-दर-लाइन पढ़ने के मानक तरीके, JSON ऐरे के साथ दोनों दिशाओं में रूपांतरण की कमांड, छह प्रकार की खराब लाइनों की तालिका और स्ट्रीमिंग HTTP प्रतिक्रियाओं से NDJSON उपभोग का सही तरीका बताती है।

मध्यम~9 मिनट पढ़ें2026-11-06 को अपडेट किया गया