Swift में YAML का उपयोग: Yams लाइब्रेरी iOS/macOS

Swift में YAML (iOS/macOS): Yams लाइब्रेरी

YAML (YAML Ain't Markup Language) डेटा सीरियलाइज़ेशन का एक सुविधाजनक फ़ॉर्मेट है, जिसका उपयोग अक्सर कॉन्फ़िगरेशन फ़ाइलों, डिपेंडेंसी विवरण (जैसे docker-compose.yml) और ऐसे प्रोजेक्ट्स में किया जाता है जहाँ पढ़ने में आसान और संक्षिप्त डेटा संरचना की आवश्यकता होती है। Apple इकोसिस्टम में Swift पर YAML के साथ काम करने के लिए कई लाइब्रेरीज़ हैं, लेकिन सबसे लोकप्रिय और स्थिर Yams है — जो पूरी तरह से Swift में लिखी गई एक तेज़ और उपयोग में आसान लाइब्रेरी है।

Yams क्या है?

Yams एक ओपन-सोर्स लाइब्रेरी है जो Swift में YAML को पार्स और सीरियलाइज़ करने की पूरी सुविधा प्रदान करती है। यह iOS, macOS, tvOS और watchOS के साथ संगत है। Yams YAML 1.2 स्पेसिफिकेशन को सपोर्ट करती है और YAML स्ट्रिंग्स को Swift स्ट्रक्चर्स (डिक्शनरी, ऐरे, स्ट्रिंग्स, नंबर, बूलियन वैल्यू) में और वापस कन्वर्ट करने की अनुमति देती है।

Yams की मुख्य विशेषताएँ:

• YAML स्ट्रिंग को Any (आमतौर पर [String: Any] या [Any]) में पार्स करना।
• Swift ऑब्जेक्ट्स को वापस YAML में सीरियलाइज़ करना।
• नेस्टेड स्ट्रक्चर, ऐरे और मल्टीपल डॉक्यूमेंट्स को सपोर्ट करना।
• विस्तृत संदेशों के साथ एरर हैंडलिंग।
• Swift Package Manager (SPM) और CocoaPods के साथ पूरी तरह से संगत।

प्रोजेक्ट में Yams इंस्टॉल करना

आप Yams को Swift Package Manager (अनुशंसित) या CocoaPods के माध्यम से इंस्टॉल कर सकते हैं।

Swift Package Manager के माध्यम से

1. Xcode में File → Add Packages चुनें।
2. रिपॉजिटरी URL डालें: https://github.com/jpsim/Yams.git
3. वर्जन चुनें (नवीनतम स्थिर वर्जन अनुशंसित) और Add Package पर क्लिक करें।

या Package.swift में डिपेंडेंसी जोड़ें:

// swift-tools-version:5.7
import PackageDescription

let package = Package(
    name: "MyProject",
    dependencies: [
        .package(url: "https://github.com/jpsim/Yams.git", from: "5.0.0")
    ],
    targets: [
        .target(
            name: "MyProject",
            dependencies: ["Yams"])
    ]
)

CocoaPods के माध्यम से

अपने Podfile में यह लाइन जोड़ें:

pod 'Yams', '~> 5.0'

फिर pod install चलाएँ।

बेसिक उपयोग: YAML पार्सिंग

इंस्टॉल करने के बाद, लाइब्रेरी को इम्पोर्ट करें और स्ट्रिंग को पार्स करने के लिए Yams.load(yaml:) का उपयोग करें।

import Yams

let yamlString = """
name: Swift
type: language
versions:
  - 5.5
  - 5.6
  - 5.7
features:
  protocol_oriented: true
  value_semantics: true
"""

do {
    if let data = try Yams.load(yaml: yamlString) as? [String: Any] {
        print("नाम: \(data["name"] ?? "")")
        print("वर्जन: \(data["versions"] ?? [])")
        if let features = data["features"] as? [String: Bool] {
            print("प्रोटोकॉल ओरिएंटेड: \(features["protocol_oriented"] ?? false)")
        }
    }
} catch {
    print("YAML पार्सिंग में त्रुटि: \(error.localizedDescription)")
}

आउटपुट:

नाम: Swift
वर्जन: [5.5, 5.6, 5.7]
प्रोटोकॉल ओरिएंटेड: true

Swift ऑब्जेक्ट्स को YAML में सीरियलाइज़ करना

वापस कन्वर्ट करने के लिए Yams.dump(object:) का उपयोग करें:

import Yams

let dictionary: [String: Any] = [
    "app": "MyApp",
    "version": 2.0,
    "features": ["dark_mode", "notifications"],
    "settings": [
        "autosave": true,
        "timeout": 30
    ]
]

do {
    let yamlString = try Yams.dump(object: dictionary)
    print(yamlString)
} catch {
    print("सीरियलाइज़ेशन में त्रुटि: \(error.localizedDescription)")
}

आउटपुट:

app: MyApp
features:
  - dark_mode
  - notifications
settings:
  autosave: true
  timeout: 30
version: 2.0

एकाधिक YAML डॉक्यूमेंट्स के साथ काम करना

YAML एक ही फ़ाइल में कई डॉक्यूमेंट्स को सपोर्ट करता है। Yams के साथ, आप Yams.loadMultiple(yaml:) का उपयोग करके उन्हें पार्स कर सकते हैं:

import Yams

let multiYAML = """
---
document: 1
data: पहला दस्तावेज़
---
document: 2
data: दूसरा दस्तावेज़
"""

do {
    let documents = try Yams.loadMultiple(yaml: multiYAML) as? [Any]
    for (index, doc) in (documents ?? []).enumerated() {
        print("दस्तावेज़ \(index + 1): \(doc)")
    }
} catch {
    print("त्रुटि: \(error.localizedDescription)")
}

आउटपुट:

दस्तावेज़ 1: ["document": 1, "data": "पहला दस्तावेज़"]
दस्तावेज़ 2: ["document": 2, "data": "दूसरा दस्तावेज़"]

Yams के साथ कस्टम टाइप्स

आप अपने कस्टम Swift स्ट्रक्चर को YAML में सीरियलाइज़ और डी-सीरियलाइज़ करने के लिए Codable प्रोटोकॉल का उपयोग कर सकते हैं:

import Yams

struct AppConfig: Codable {
    let appName: String
    let version: Double
    let features: [String]
}

let config = AppConfig(appName: "MyApp", version: 2.0, features: ["dark_mode", "notifications"])

do {
    let encoder = YAMLEncoder()
    let yamlString = try encoder.encode(config)
    print(yamlString)
    
    let decoder = YAMLDecoder()
    let decodedConfig = try decoder.decode(AppConfig.self, from: yamlString)
    print("डीकोड किया गया: \(decodedConfig)")
} catch {
    print("त्रुटि: \(error.localizedDescription)")
}

आउटपुट:

appName: MyApp
version: 2.0
features:
  - dark_mode
  - notifications

डीकोड किया गया: AppConfig(appName: "MyApp", version: 2.0, features: ["dark_mode", "notifications"])

निष्कर्ष

Yams Swift में YAML के साथ काम करने के लिए एक शक्तिशाली और उपयोग में आसान लाइब्रेरी है। चाहे आप कॉन्फ़िगरेशन फ़ाइलों को पार्स कर रहे हों, डेटा को सीरियलाइज़ कर रहे हों, या कस्टम टाइप्स के साथ काम कर रहे हों, Yams आपकी सभी ज़रूरतों को पूरा करता है। इसकी SPM और CocoaPods के साथ संगतता इसे किसी भी iOS/macOS प्रोजेक्ट में एकीकृत करना आसान बनाती है।

Yams के साथ अपने Swift प्रोजेक्ट्स में YAML का उपयोग शुरू करें और अपने डेटा प्रबंधन को अधिक कुशल और पठनीय बनाएँ!