विकृत JSON फ़ाइलों को तुरंत कैसे ठीक करें: डेवलपर्स के लिए

आपका API कॉल JSONDecodeError: Expecting property name enclosed in double quotes के साथ विफल हो गया। समय निकल रहा है। डेटा किसी LLM से आया था, और उस 2,000 टोकन के रिस्पॉन्स में कहीं एक सिंगल ट्रेलिंग कॉमा ने आपकी पूरी पाइपलाइन खराब कर दी।

मई 2026 तक, विकृत JSON फ़ाइलों को ठीक करने का सबसे तेज़ तरीका json_repair (Python) या jsonrepair (npm) जैसी स्वचालित लाइब्रेरी का उपयोग करना है। ये टूल विशेष रूप से LLM-उत्पन्न सिंटैक्स त्रुटियों को तुरंत ठीक करने के लिए बनाए गए हैं। मैन्युअल रिपेयर के लिए, सामान्य संदिग्ध ट्रेलिंग कॉमा, सिंगल कोट्स, या बिना कोट वाली कुंजी होते हैं — ये RFC 8259 मानक के तीन सबसे आम उल्लंघन हैं।

सबसे तेज़ समाधान: LLM आउटपुट के लिए json_repair

Python के json.loads() जैसे मानक पार्सर डिज़ाइन से ही सख्त होते हैं। एक ग़लत स्थान पर रखा गया कैरेक्टर JSONDecodeError को ट्रिगर कर देता है और सब कुछ रुक जाता है। 2026 में यह एक रोज़मर्रा की समस्या है क्योंकि LLM अक्सर JSON को संवादात्मक टेक्स्ट में लपेट देते हैं, रिस्पॉन्स को वाक्य के बीच में काट देते हैं, या ऐसी टिप्पणियाँ बिखेर देते हैं जो स्पेक को तोड़ देती हैं।

json_repair लाइब्रेरी पसंदीदा समाधान है। GitHub के अनुसार, इस प्रोजेक्ट के 2026 तक 4,700 से अधिक स्टार्स हैं। यह स्ट्रिंग के इरादे का “अनुमान” लगाकर काम करता है — ग़ायब ब्रैकेट्स को बंद करना, कोट्स जोड़ना, और JSON ब्लॉक के चारों ओर के अतिरिक्त टेक्स्ट को हटाना।

json_repair की सरल 3-चरण प्रक्रिया: इनपुट (विकृत) -> इरादे का अनुमान -> आउटपुट (मान्य)

Python: पहले और बाद में

इंस्टॉल करें: pip install json-repair

विकृत इनपुट:

import json_repair

bad_json = '{"user": "Alice", "status": tru'
decoded_object = json_repair.loads(bad_json)

पर्दे के पीछे क्या हुआ: json_repair ने देखा कि tru संभवतः true था, ग़ायब क्लोजिंग ब्रेस जोड़ दी, और एक मान्य Python डिक्शनरी लौटा दी। बिल्कुल शून्य मैन्युअल हस्तक्षेप।

Salvage मोड: जब डेटा सच में भद्दा हो

अधिक कठिन मामलों के लिए, json_repair (v0.59.5+) में एक Salvage मोड शामिल है। जैसा कि प्रोजेक्ट डॉक्यूमेंटेशन में बताया गया है, यह मोड विशेष रूप से कटे हुए AI रिस्पॉन्स या दूषित लॉग के लिए बनाया गया है। यह ऐरे (arrays) को जबरन ऑब्जेक्ट्स में बदल सकता है या उन आइटम्स को हटा सकता है जिन्हें बचाना असंभव है, यह सुनिश्चित करते हुए कि आउटपुट आपके स्कीमा में फ़िट हो।

import json_repair

# Salvage mode for severely truncated data
result = json_repair.loads(
    '{"items": [{"id": 1, "name": "Widget"}, {"id": 2, "na',
    salvage_mode=True
)
# Result: {'items': [{'id': 1, 'name': 'Widget'}, {'id': 2}]}
# Dropped the incomplete 'na' but saved everything else

npm विकल्प

Node.js प्रोजेक्ट्स के लिए, jsonrepair CLI वही काम संभालता है:

# Fix a file in place
npx jsonrepair broken.json > fixed.json

# Fix a string in a script
const { jsonrepair } = require('jsonrepair');
const fixed = jsonrepair('{"name": "test",}');

मैन्युअल डिबगिंग: खोजें कि स्पेक को किसने तोड़ा

जब स्वचालन काम नहीं करता, तो आपको यह पता लगाना होगा कि फ़ाइल RFC 8259 का उल्लंघन कहाँ करती है। JSON, YAML या JavaScript की तुलना में कहीं अधिक सख्त है। जैसा कि JSONParser डायग्नोस्टिक्स टीम समझाती है, “पार्सर उस पहले कैरेक्टर पर विफल हो जाता है जिसे वह समझ नहीं पाता, और यह अक्सर कई पंक्तियों पहले मौजूद किसी समस्या का डाउनस्ट्रीम लक्षण होता है।”

तीन JSON किलर्स

किलर 1: ट्रेलिंग कॉमा

DEV Community के अनुसार, ट्रेलिंग कॉमा पार्स विफलताओं का नंबर एक कारण है। ये JavaScript में ठीक हैं लेकिन JSON ऐरे या ऑब्जेक्ट में आखिरी आइटम के बाद ग़ैर-क़ानूनी हैं।

// BROKEN - trailing comma after "active"
{
  "name": "Alice",
  "status": "active",
}

// FIXED - no comma before closing brace
{
  "name": "Alice",
  "status": "active"
}

किलर 2: सिंगल कोट्स

JSON, कुंजी और स्ट्रिंग मान दोनों के लिए डबल कोट्स (") की आवश्यकता करता है। कई Python और JavaScript डेवलपर्स गलती से सिंगल कोट्स (') का उपयोग कर लेते हैं। जैसा कि TidyCode बताता है, यह एक अनिवार्य सुधार है।

// BROKEN - single quotes
{'name': 'Alice'}

// FIXED - double quotes
{"name": "Alice"}

किलर 3: बिना कोट वाली कुंजी

JavaScript में आप { name: "Alice" } लिख सकते हैं। लेकिन JSON में, हर कुंजी को डबल कोट्स की आवश्यकता होती है।

// BROKEN - unquoted key
{name: "Alice"}

// FIXED - quoted key
{"name": "Alice"}

अमान्य बनाम मान्य JSON सिंटैक्स की साइड-बाय-साइड तुलना

“Unexpected Token” त्रुटि

जब कोई वैलिडेटर “Unexpected Token” फ़्लैग करता है, तो इसका मतलब है कि पार्सर NaN, Infinity, या undefined से टकरा गया — वे JavaScript कॉन्स्टेंट्स जिन्हें JSON समर्थन नहीं करता। JSON केवल null, true, false, और संख्याओं की अनुमति देता है।

// BROKEN - NaN is not valid JSON
{"score": NaN, "result": Infinity}

// FIXED - replace with null or valid values
{"score": null, "result": null}

सख्त पार्सिंग बनाम रिपेयर पार्सिंग: कौन-सा कब उपयोग करें

सही दृष्टिकोण इस बात पर निर्भर करता है कि आपका डेटा कहाँ से आता है। मानव-संपादित कॉन्फ़िग फ़ाइलें लेखक को गलतियाँ ठीक करने के लिए मजबूर करने हेतु सख्त पार्सिंग की हक़दार हैं। LLMs या API लॉग से आने वाले मशीन-जनित डेटा को रिपेयर-आधारित पार्सिंग की आवश्यकता होती है।

विशेषता	सख्त (`json.loads`)	रिपेयर (`json_repair`)
ट्रेलिंग कॉमा	`JSONDecodeError` उठाता है	स्वचालित रूप से हटाया जाता है
सिंगल कोट्स	विफल	डबल कोट्स में परिवर्तित
कटा हुआ डेटा	विफल	खुले ब्रैकेट्स/कोट्स बंद करता है
टिप्पणियाँ	विफल	स्वचालित रूप से हटाई जाती हैं
सर्वोत्तम उपयोग	मानव-संपादित कॉन्फ़िग फ़ाइलें	LLM आउटपुट, API लॉग

Pydantic के साथ स्कीमा-निर्देशित रिपेयर

आप Pydantic v2 या JSON Schema का उपयोग करके रिपेयर प्रक्रिया का मार्गदर्शन कर सकते हैं। json_repair को एक स्कीमा देने पर, टूल सिर्फ़ सिंटैक्स ठीक नहीं करता — यह प्रकार भी सुधार सकता है (स्ट्रिंग "1" को संख्या 1 में बदलना) और डिफ़ॉल्ट मानों से ग़ायब आवश्यक फ़ील्ड भर सकता है।

from pydantic import BaseModel
import json_repair

class User(BaseModel):
    id: int
    name: str
    active: bool = True

# Broken JSON with wrong types
raw = '{"id": "42", "name": "Alice"}'
repaired = json_repair.loads(raw)

# Validate against schema
user = User(**repaired)
# user.id is now int(42), user.active defaults to True

जैसा कि Stefano Baccianella ने अपने 2025 प्रोजेक्ट साइटेशन में नोट किया, यह दृष्टिकोण उस “अधिकांशतः सही लेकिन तकनीकी रूप से अमान्य” JSON के लिए अनुकूलित है जिसे भाषा मॉडल आमतौर पर उत्पन्न करते हैं।

मल्टी-गीगाबाइट फ़ाइलों को क्रैश किए बिना संभालना

10KB स्निपेट को ठीक करना आसान है। एक 2GB फ़ाइल को ठीक करने के लिए ऐसी रणनीति चाहिए जो आपकी सारी RAM न खा जाए। पूरी फ़ाइल को मेमोरी में लोड करने से Out-of-Memory (OOM) त्रुटियाँ होती हैं।

रणनीति 1: ijson के साथ स्ट्रीमिंग

विशाल डेटासेट के लिए, डेटा को टुकड़े-दर-टुकड़ा प्रोसेस करने हेतु ijson का उपयोग करें। जैसा कि Scrapfly बताता है, ijson डेटा को वृद्धिशील रूप से प्रोसेस करता है। इे एक क्लीनअप स्क्रिप्ट के साथ जोड़ें जो पार्स करने से पहले लाइन-दर-लाइन समस्याओं को ठीक करती है।

import ijson

# Stream through a large JSON file
with open('huge_broken.json', 'r') as f:
    for item in ijson.items(f, 'records.item'):
        # Process each item individually
        process(item)

रणनीति 2: अधिकतम दक्षता के लिए CLI पाइप

बड़ी फ़ाइलों के लिए सबसे मेमोरी-कुशल दृष्टिकोण jsonrepair CLI का उपयोग करना और आउटपुट को सीधे एक नई फ़ाइल में पाइप करना है:

# Streams repair, never loads full file into memory
jsonrepair large_broken.json > fixed.json

यह फ़ाइल को Python या ब्राउज़र में लोड करने की तुलना में कहीं अधिक मेमोरी-कुशल है।

निष्कर्ष

json_repair जैसी AI-जागरूक लाइब्रेरियों के लिए धन्यवाद, विकृत JSON को ठीक करना अब मैन्युअल काम नहीं है। आपको अभी भी RFC 8259 के मूल सिद्धांतों को समझना होगा — कोई ट्रेलिंग कॉमा नहीं, कोई सिंगल कोट्स नहीं, कोई बिना कोट वाली कुंजी नहीं — लेकिन 2026 में बड़े पैमाने पर डेटा के लिए स्वचालन ही एकमात्र व्यावहारिक दृष्टिकोण है।

वर्कफ़्लो सरल है: पहले रिपेयर लाइब्रेरी आज़माएँ। यदि वह विफल हो, तो सटीक सिंटैक्स त्रुटि का पता लगाने के लिए वैलिडेटर का उपयोग करें। इससे आपके एप्लिकेशन तब भी चलते रहते हैं जब आने वाला डेटा पूरी तरह सही न हो।

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

क्या JSON आधिकारिक रूप से टिप्पणियों या सिंगल कोट्स का समर्थन करता है?

नहीं। RFC 8259 मानक सख्ती से टिप्पणियों को मना करता है। सिंगल कोट्स भी अमान्य हैं — कुंजी और स्ट्रिंग के लिए केवल डबल कोट्स की अनुमति है। हालाँकि, json_repair जैसे टूल टिप्पणियाँ हटा और कोट्स स्वचालित रूप से परिवर्तित कर सकते हैं ताकि फ़ाइलें मानक लाइब्रेरी द्वारा पार्स हो सकें।

मैं बिना क्रैश किए बहुत बड़ी विकृत JSON फ़ाइलों को कैसे संभालूँ?

डेटा को टुकड़ों में प्रोसेस करने के लिए ijson जैसे स्ट्रीमिंग पार्सर का उपयोग करें। पूरी विकृत स्ट्रिंग को एक ही वैरिएबल में लोड करने से बचें। सबसे तेज़ परिणामों के लिए CLI रिपेयर टूल का उपयोग करें जो आउटपुट को सीधे डिस्क पर एक नई फ़ाइल में पाइप करते हैं बिना सब कुछ मेमोरी में रखे।

विकृत JSON और अमान्य JSON में क्या अंतर है?

विकृत (malformed) JSON सिंटैक्स नियमों का उल्लंघन करता है — ग़ायब ब्रैकेट्स, बिना कोट वाली कुंजी, ट्रेलिंग कॉमा — जिससे इसे पार्स करना असंभव हो जाता है। अमान्य (invalid) JSON सभी सिंटैक्स नियमों का पालन करता है लेकिन किसी विशिष्ट JSON Schema से मेल नहीं खाता (उदा., कोई फ़ील्ड स्ट्रिंग है जबकि स्कीमा पूर्णांक चाहिए)। विकृत JSON ठीक करना संरचनात्मक रिपेयर है; अमान्य JSON ठीक करना डेटा अखंडता का विषय है।

क्या मैं json_repair को Pydantic सत्यापन के साथ उपयोग कर सकता हूँ?

हाँ। पहले json_repair.loads() चलाएँ ताकि सिंटैक्स त्रुटियाँ ठीक हों, फिर टाइप सत्यापन और स्कीमा प्रवर्तन के लिए रिपेयर की गई डिक्शनरी को अपने Pydantic मॉडल को पास करें। यह दो-चरणीय दृष्टिकोण संरचनात्मक और अर्थ संबंधी दोनों समस्याओं को संभालता है।

JavaScript-शैली की टिप्पणियों वाले JSON का क्या?

मानक JSON टिप्पणियों का समर्थन नहीं करता, लेकिन json_repair स्वचालित रूप से // और /* */ टिप्पणियाँ हटा सकता है। यदि आपको अपनी कॉन्फ़िग फ़ाइलों में टिप्पणियाँ चाहिए, तो JSONC (टिप्पणियों वाला JSON) फ़ॉर्मेट और Python के लिए json5 जैसे संगत पार्सर पर विचार करें।

विकृत JSON फ़ाइलों को तुरंत कैसे ठीक करें: डेवलपर्स के लिए फ़ील्ड मैन्युअल