JSONSerialization: यह क्या है, Foundation क्लास के तरीके और यह कैसे काम करता है

JSONSerialization क्या है

JSONSerialization Foundation फ्रेमवर्क का एक क्लास है जो iOS, macOS, tvOS और watchOS पर उपलब्ध है। यह JSON Data को Foundation ऑब्जेक्ट्स (NSDictionary, NSArray, NSString, NSNumber) में बदलने और वापस लाने की विधियाँ प्रदान करता है। यह क्लास iOS 5 में दिखाई दिया और Codable (Swift 4) की शुरुआत तक Apple प्लेटफ़ॉर्म पर JSON के साथ काम करने का प्राथमिक तरीका बना रहा। अपनी उम्र के बावजूद, JSONSerialization लीगेसी Objective-C प्रोजेक्ट्स और उन परिदृश्यों में प्रासंगिक बना हुआ है जहाँ बिना निश्चित मॉडल स्कीमा के डायनामिक JSON प्रोसेसिंग की आवश्यकता होती है।

JSONSerialization का उपयोग कब किया जाता है

Codable के आगमन के बावजूद, JSONSerialization कई परिदृश्यों में प्रासंगिक बना हुआ है। डायनामिक JSON संरचना — जब प्रतिक्रिया प्रारूप बदलता है या पहले से अज्ञात होता है — के लिए कुंजियों द्वारा शब्दकोशों तक पहुँचने की आवश्यकता होती है, जो JSONSerialization के माध्यम से करना आसान है। इस क्लास का उपयोग Objective-C प्रोजेक्ट्स में भी किया जाता है जहाँ Codable उपलब्ध नहीं है, और बड़ी JSON फ़ाइलों के क्रमिक पार्सिंग के लिए स्ट्रीम के साथ काम करते समय किया जाता है। परीक्षणों और मॉकअप में, isValidJSONObject और data(withJSONObject:options:) बिना थर्ड-पार्टी लाइब्रेरी के तेज़ी से JSON फिक्स्चर उत्पन्न करने की अनुमति देते हैं, जिससे विकास और प्रोटोटाइपिंग में तेज़ी आती है।

import Foundation

// JSONSerialization के उपयोग की मूल संरचना
let jsonString = """
{
    "id": 1,
    "name": "John Doe",
    "email": "john@example.com"
}
"""

guard let jsonData = jsonString.data(using: .utf8) else {
    return
}

do {
    let json = try JSONSerialization
        .jsonObject(with: jsonData,
                       options: .mutableContainers)
    print(json)
} catch {
    print("JSON पार्स त्रुटि: \(error)")
}

क्लास की मुख्य विधियाँ

JSONSerialization JSON के साथ काम करने के लिए चार मुख्य विधियाँ प्रदान करता है। मुख्य विधि jsonObject(with:options:) है, जो Data को Foundation ऑब्जेक्ट्स में बदलती है। data(withJSONObject:options:) विधि रिवर्स सीरियलाइज़ेशन करती है। isValidJSONObject(_:) जाँचता है कि क्या किसी ऑब्जेक्ट को सीरियलाइज़ किया जा सकता है। writeJSONObject(_:to:options:error:) JSON को सीधे स्ट्रीम में लिखता है। InputStream से JSON पढ़ने के लिए, jsonObject(with:options:) विधि मौजूद है जो Data के बजाय स्ट्रीम स्वीकार करती है, जो स्ट्रीमिंग डेटा लौटाने वाले नेटवर्क अनुरोधों के साथ एकीकृत करते समय सुविधाजनक है।

JSONObject और JSONData

jsonObject विधि Data स्वीकार करती है और Any लौटाती है — आमतौर पर NSDictionary या NSArray। सुरक्षित उपयोग के लिए, परिणाम को सशर्त कास्टिंग के माध्यम से अपेक्षित प्रकार में बदला जाता है। data विधि एक Foundation ऑब्जेक्ट स्वीकार करती है और JSON प्रतिनिधित्व के साथ Data लौटाती है। .prettyPrinted विकल्प पठनीयता के लिए इंडेंटेशन के साथ फ़ॉर्मेटिंग जोड़ता है।

let jsonString = """
{
    "products": [
        {"id": 1, "name": "iPhone", "price": 999},
        {"id": 2, "name": "iPad", "price": 799}
    ]
}
"""
let data = Data(jsonString.utf8)

if let json = try? JSONSerialization
    .jsonObject(with: data) as? [String: Any],
    let products = json["products"] as? [[String: Any]] {

    for product in products {
        if let name = product["name"] as? String {
            print("उत्पाद: \(name)")
        }
    }
}

// रिवर्स सीरियलाइज़ेशन: ऑब्जेक्ट -> JSON
let outputDict: [String: Any] = ["status": "ok", "count": 42]
if let outputData = try? JSONSerialization
    .data(withJSONObject: outputDict,
                options: .prettyPrinted) {
    String(data: outputData, encoding: .utf8)
}

JSON पार्सिंग के उदाहरण

मूल पार्सिंग आदिम प्रकारों वाले शब्दकोश की JSONSerialization के साथ सबसे आम संक्रिया है। URLSession के माध्यम से Data प्राप्त करने के बाद, डेवलपर jsonObject को कॉल करता है और परिणाम को अपेक्षित प्रकार में बदलता है। ऑब्जेक्ट्स की सरणियों के लिए, [[String: Any]] में कास्टिंग का उपयोग किया जाता है, जिसके बाद प्रत्येक तत्व को एक लूप में संसाधित किया जाता है। यह दृष्टिकोण लचीला है लेकिन मैन्युअल प्रकार प्रबंधन की आवश्यकता है।

नेस्टेड संरचनाओं का पार्सिंग

वास्तविक API सरणियों, दिनांकों और वैकल्पिक फ़ील्ड्स के साथ जटिल नेस्टेड JSON ऑब्जेक्ट्स लौटाते हैं। JSONSerialization किसी भी नेस्टिंग गहराई को सही ढंग से संभालता है, लेकिन डेवलपर को प्रत्येक स्तर को स्वतंत्र रूप से आवश्यक प्रकार में बदलना होगा। इस कार्य को सरल बनाने के लिए, Apple टाइप किए गए डेटा के लिए Codable और केवल डायनामिक संरचनाओं के लिए JSONSerialization का उपयोग करने की अनुशंसा करता है।

// API प्रतिक्रिया का पार्सिंग
func parseUserResponse(data: Data) {
    do {
        guard let json = try JSONSerialization
            .jsonObject(with: data) as? [String: Any]
        else { return }

        guard let userId = json["id"] as? Int,
              let name = json["name"] as? String
        else {
            throw ParsingError.missingField
        }

        print("उपयोगकर्ता: \(name) (ID: \(userId))")

    } catch let error as ParsingError {
        print("पार्स विफल: \(error)")
    } catch {
        print("अप्रत्याशित त्रुटि: \(error)")
    }
}

enum ParsingError: Error {
    case missingField
    case invalidType
}

त्रुटि प्रबंधन

JSONSerialization अमान्य JSON, प्रकार बेमेल, या नेस्टिंग गहराई से अधिक होने पर त्रुटियाँ फेंकता है। त्रुटियाँ CocoaError प्रकार की होती हैं और समस्या का वर्णन करने वाला कोड रखती हैं। डेवलपर को do-catch निर्माण के माध्यम से उन्हें संभालना होगा, अन्यथा एप्लिकेशन क्रैश हो जाएगा। सबसे सामान्य त्रुटियाँ हैं: NSPropertyListReadCorruptError (अमान्य JSON) और NSPropertyListReadUnknownError। प्रत्येक त्रुटि प्रकार की अपनी हैंडलिंग रणनीति की आवश्यकता होती है: अमान्य प्रारूप के लिए, डेटा पुनः भेजने का अनुरोध करें, और संरचना बेमेल के लिए, पार्सिंग मॉडल अपडेट करें।

डीसीरियलाइज़ेशन त्रुटियों के प्रकार

अमान्य JSON — विफलता का सबसे सामान्य कारण: एक लापता अल्पविराम, अतिरिक्त वर्ण, या अनएस्केप्ड उद्धरण पूरे पार्सिंग को तोड़ देता है। दूसरे प्रकार की त्रुटियाँ अपेक्षित संरचना से बेमेल है: उदाहरण के लिए, सर्वर ने शब्दकोश के बजाय एक सरणी लौटाई। JSONSerialization.fragmentsAllowed उस JSON को पढ़ने की अनुमति देता है जिसका मूल शब्दकोश या सरणी नहीं बल्कि एक आदिम मान है। डेवलपर को नेस्टिंग गहराई से अधिक होने की त्रुटि का भी सामना करना पड़ सकता है जब JSON में बहुत अधिक पदानुक्रम स्तर हों।

पढ़ने और लिखने के विकल्प

JSONSerialization पार्सिंग कॉन्फ़िगर करने के लिए कई विकल्प प्रदान करता है। .mutableContainers अपरिवर्तनीय संस्करणों के बजाय NSMutableDictionary और NSMutableArray लौटाता है, जो पार्सिंग के बाद डेटा को संशोधित करते समय उपयोगी है। .mutableLeaves स्ट्रिंग मानों को परिवर्तनीय बनाता है। .fragmentsAllowed उस JSON की अनुमति देता है जिसका मूल कोई ऑब्जेक्ट या सरणी नहीं बल्कि एक स्ट्रिंग या संख्या है — सरल API प्रतिक्रियाओं के लिए सुविधाजनक। .withoutEscapingSlashes और .sortedKeys विकल्प data(withJSONObject:options:) विधि के लिए उपलब्ध हैं, जो सीरियलाइज़्ड JSON के फ़ॉर्मेटिंग को नियंत्रित करते हैं। विकल्प बिटमास्क के रूप में पारित किए जाते हैं, जो लचीले पार्सिंग कॉन्फ़िगरेशन के लिए | ऑपरेटर के माध्यम से कई मानों को संयोजित करने की अनुमति देते हैं।

// विभिन्न प्रकार की त्रुटियों का प्रबंधन
func safeParse(jsonData: Data) {
    do {
        let object = try JSONSerialization
            .jsonObject(with: jsonData,
                           options: .fragmentsAllowed)

        if let dictionary = object as? [String: Any] {
            print("\(dictionary.count) कुंजियों वाला शब्दकोश")
        } else if let array = object as? [Any] {
            print("\(array.count) आइटम वाली सरणी")
        }

    } catch CocoaError.propertyListReadCorrupt {
        print("दूषित JSON डेटा")
    } catch let error as CocoaError {
        print("Cocoa त्रुटि: \(error)")
    } catch {
        print("अज्ञात त्रुटि: \(error)")
    }
}

// सीरियलाइज़ेशन से पहले ऑब्जेक्ट की वैधता जाँच
let testObject: [String: Any] = ["key": "value", "nested": ["a": 1]]
if JSONSerialization.isValidJSONObject(testObject) {
    print("मान्य JSON ऑब्जेक्ट")
}

JSONSerialization का प्रदर्शन डेटा आकार और कॉल आवृत्ति पर निर्भर करता है। एक छोटे सर्वर प्रतिक्रिया के एकल पार्सिंग के लिए, अंतर नगण्य है, लेकिन दसियों मेगाबाइट JSON या लूप में बार-बार कॉल प्रोसेस करते समय, प्रकार कास्टिंग से ओवरहेड पर विचार किया जाना चाहिए। JSONSerialization वर्तमान थ्रेड में समकालिक रूप से काम करता है, इसलिए बड़े दस्तावेज़ों के लिए DispatchQueue.global() के माध्यम से पार्सिंग को पृष्ठभूमि कतार में ले जाने की अनुशंसा की जाती है। वैकल्पिक रूप से, आप पूरी फ़ाइल को मेमोरी में लोड किए बिना स्ट्रीमिंग प्रोसेसिंग के लिए InputStream का उपयोग कर सकते हैं, जो सीमित संसाधनों वाले अनुप्रयोगों के लिए महत्वपूर्ण है। JSON को फ़ाइल या नेटवर्क स्ट्रीम में लिखने के लिए, writeJSONObject(_:to:options:error:) विधि मध्यवर्ती Data ऑब्जेक्ट बनाए बिना सीधे OutputStream को सीरियलाइज़्ड डेटा भेजने की अनुमति देती है, जो बड़े दस्तावेज़ों के साथ काम करते समय मेमोरी खपत को कम करती है।