Rust में घुंघराले कोष्ठक: format! में { और } को त्रुटियों के बिना कैसे प्रदर्शित करें

परिचय: Rust घुंघराले कोष्ठकों को क्यों पसंद नहीं करता?

यदि आपने कभी Rust में लिखा है और println! के माध्यम से { "name": "Rust" } जैसा कुछ प्रदर्शित करने का प्रयास किया है, तो आपने निश्चित रूप से यह देखा होगा:

println!("{ "name": "Rust" }"); // संकलन त्रुटि!

कंपाइलर दुर्भावनापूर्ण ढंग से कहता है: "invalid reference to argument 'name' — no argument named 'name' found"। और आप हैरान रह जाते हैं: स्ट्रिंग में घुंघराले कोष्ठक कैसे प्रदर्शित करें? Python में यह {{ }} के माध्यम से किया जाता है, लेकिन वहाँ यह आसान है। Rust का अपना दर्शन है: घुंघराले कोष्ठक केवल प्रतीक नहीं हैं, बल्कि Python से उधार ली गई एक शक्तिशाली फ़ॉर्मेटिंग प्रणाली का हिस्सा हैं, लेकिन इसमें बारीकियाँ हैं।

इस लेख में हम Rust में घुंघराले कोष्ठकों को एस्केप करने के सभी तरीकों पर चर्चा करेंगे: बुनियादी {{ }} से लेकर Debug और raw string literals के साथ तरकीबों तक। आप सीखेंगे कि JSON कैसे आउटपुट करें, कोड कैसे जनरेट करें और कंपाइलर के जाल में फंसे बिना टेम्पलेट्स के साथ कैसे काम करें।

घुंघराले कोष्ठक विशेष क्यों हैं?

Rust में, मैक्रोज़ format!, println!, write! और format_args! घुंघराले कोष्ठकों को प्लेसहोल्डर मार्कर के रूप में उपयोग करते हैं। उदाहरण के लिए:

let name = "Rust";\nprintln!("Hello, {}!", name); // Hello, Rust!

यहाँ {} एक placeholder है, जो वेरिएबल के मान से बदल दिया जाता है। लेकिन क्या होगा यदि आपको स्वयं { या } प्रतीक की आवश्यकता है? Rust एक सरल तरकीब का उपयोग करता है: कोष्ठकों को दोगुना करना।

विधि 1: क्लासिक दोहरीकरण {{ और }}

सबसे सरल और स्पष्ट तरीका है एक के बाद एक दो घुंघराले कोष्ठक लिखना। पहली जोड़ी {{ एक { में बदल जाती है, और }} एक } में बदल जाती है।

उदाहरण 1: सरल एस्केपिंग

fn main() {\n    let text = format!("फ़ंक्शन main() {{ ... }}");\n    println!("{}", text);\n    // आउटपुट: फ़ंक्शन main() { ... }\n}

उदाहरण 2: प्रतिस्थापन के साथ एस्केपिंग

fn main() {\n    let lang = "Rust";\n    let year = 2015;\n    let result = format!("{{ \\"lang\\": \\"{}\\", \\"year\\": {} }}", lang, year);\n    println!("{}", result);\n    // आउटपुट: { "lang": "Rust", "year": 2015 }\n}

यह विधि हर जगह काम करती है: println!, write!, format! में। नियम याद रखें: दो कोष्ठक = एक कोष्ठक।

विधि 2: नामित तर्क और एस्केपिंग

यदि आप नामित तर्कों का उपयोग करते हैं (जैसे, {name}), तो एस्केपिंग भी काम करता है, लेकिन कोष्ठकों की स्थिति पर ध्यान देने की आवश्यकता है।

उदाहरण 3: नामित प्लेसहोल्डर और कोष्ठक

fn main() {\n    let user = "Alice";\n    // हम प्रदर्शित करना चाहते हैं: नमस्ते, {Alice}!\n    println!("नमस्ते, {{{}}}!", user);\n    // आउटपुट: नमस्ते, {Alice}!\n}

स्ट्रिंग "नमस्ते, {{{}}}!" को समझें:\n

\n
• {{ → { प्रदर्शित करता है
\n
• {} → user को प्रतिस्थापित करता है
\n
• }} → } प्रदर्शित करता है
\n

महत्वपूर्ण: एस्केपिंग के लिए कोष्ठकों की संख्या हमेशा सम होनी चाहिए। यदि आपके पास {{{ है, तो यह एक त्रुटि है, क्योंकि तीन कोष्ठक एक सही जोड़ी नहीं बनाते हैं।

विधि 3: Debug-फ़ॉर्मेट ({:?}) का उपयोग करना

कभी-कभी आप किसी डेटा संरचना को इस तरह प्रदर्शित करना चाहते हैं कि वह स्वचालित रूप से घुंघराले कोष्ठकों के साथ दिखाई दे। उदाहरण के लिए, डीबगिंग या JSON जनरेशन के दौरान।

उदाहरण 4: Debug के माध्यम से संरचना आउटपुट

#[derive(Debug)]\nstruct Point {\n    x: i32,\n    y: i32,\n}\n\nfn main() {\n    let p = Point { x: 10, y: 20 };\n    println!("{:?}", p);\n    // आउटपुट: Point { x: 10, y: 20 }\n}

ट्रेट Debug स्वयं फ़ील्ड के चारों ओर कोष्ठक जोड़ता है। यह सुविधाजनक है यदि आपको किसी ऑब्जेक्ट की स्थिति जल्दी से दिखानी है। लेकिन यदि आपको विशेष रूप से JSON या अन्य