Rust में मल्टीलाइन स्ट्रिंग्स: सिंटैक्स, उदाहरण और टिप्स

Rust में मल्टीलाइन स्ट्रिंग्स: कोट्स और स्लैशेज से परेशान हुए बिना

नमस्ते दोस्त! अगर आपने कभी Python में कोड लिखा है, तो आप जानते हैं कि वहाँ मल्टीलाइन स्ट्रिंग बनाना कितना आसान है: बस तीन कोट्स """...""" लगाओ और काम खत्म। लेकिन जैसे ही आप Rust पर आते हैं, आपको पता चलता है कि यह पुराना तरीका यहाँ काम नहीं करता। और अब आप गूगल पर सर्च कर रहे हैं: "Rust में मल्टीलाइन स्ट्रिंग लिटरल का सिंटैक्स क्या है?" है न?

चिंता मत करो, यह Rust सीखने वालों का सबसे कॉमन सवाल है, जिसे Stack Overflow पर हज़ारों बार देखा गया है। और आज हम हमेशा के लिए समझ लेंगे कि Rust में लंबी स्ट्रिंग्स के साथ कैसे काम करें, बिना दिमाग खराब किए। चलिए शुरू करते हैं!

Rust को ट्रिपल कोट्स (Python की तरह) क्यों पसंद नहीं?

Rust एक सिस्टम लैंग्वेज है और बहुत सख्त है। यह ढीलापन बर्दाश्त नहीं करता। Rust में ट्रिपल कोट्स """ मल्टीलाइन स्ट्रिंग के लिए नहीं, बल्कि कमेंट या डॉक्यूमेंटेशन (अगर /// हो) के लिए होते हैं। तो अगर आप ऐसा लिखने की कोशिश करेंगे:

// ❌ यह काम नहीं करेगा!\nlet text = """यह\nमल्टीलाइन\nस्ट्रिंग है""";\n

कंपाइलर आपको घूरेगा और एरर देगा। Rust में मल्टीलाइन स्ट्रिंग के लिए अलग तरीका है — और यह Python से भी ज़्यादा शानदार है!

तरीका #1: सामान्य कोट्स और लाइन ब्रेक

सबसे आसान तरीका है कोड में स्ट्रिंग को तोड़ना, \\n कैरेक्टर का इस्तेमाल करके। लेकिन यह उबाऊ और पढ़ने में मुश्किल है। इससे कहीं बेहतर है असली लाइन ब्रेक का इस्तेमाल डबल कोट्स के अंदर। Rust यह करने देता है!

// ✅ यह काम करता है!\nlet poem = "यह एक स्ट्रिंग है,\nजो दो लाइनों में फैली है,\nऔर Rust में यह पूरी तरह से वैध है।";\nprintln!("{}", poem);\n

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

तरीका #2: एस्केपिंग और बैकस्लैश — आपका दोस्त (और दुश्मन)

अगर आपको कोड में लंबी स्ट्रिंग लिखनी है, लेकिन उसमें असली लाइन ब्रेक नहीं चाहिए (जैसे कि पढ़ने में आसानी के लिए), तो लाइन के अंत में बैकस्लैश का इस्तेमाल करें:

// ✅ स्ट्रिंग बिना लाइन ब्रेक के, लेकिन कोड में पढ़ने लायक\nlet long_string = "यह बहुत लंबी स्ट्रिंग है, \\\nजो कोड में कई लाइनों में बंटी है, \\\nलेकिन मेमोरी में एक ही लाइन होगी बिना \\n के।";\nprintln!("{}", long_string);\n

ध्यान दें: बैकस्लैश के बाद कोई स्पेस नहीं होना चाहिए — सीधे Enter दबाएँ। वरना Rust समझेगा कि आप स्पेस को एस्केप कर रहे हैं, और सब कुछ गड़बड़ हो जाएगा।

तरीका #3: Raw String Literals — बिना एस्केपिंग के जादू

अब यह है Rust का सीक्रेट वेपन। अगर आपको ऐसी स्ट्रिंग लिखनी है जिसमें बहुत सारे कोट्स, स्लैशेज या दूसरे स्पेशल कैरेक्टर हों (जैसे JSON, रेगुलर एक्सप्रेशन या Windows पथ), तो r"" — रॉ स्ट्रिंग लिटरल का इस्तेमाल करें।

r"..." के अंदर सभी कैरेक्टर बिल्कुल वैसे ही लिए जाते हैं जैसे वे हैं। कोई एस्केपिंग नहीं!

// ✅ Raw string — कोई स्लैश नहीं!\nlet json = r#"{\n    "name": "Rust",\n    "version": 1.75,\n    "features": ["सुरक्षा", "गति"]\n}"#;\nprintln!("{}", json);\n

लेकिन क्या होगा अगर स्ट्रिंग के अंदर "# आ जाए? इसके लिए Rust आपको कोट्स के चारों ओर # की संख्या बढ़ाने की अनुमति देता है: r##"..."##, r###"..."### और ऐसे ही अनंत तक। बस इतने # चुनें जो आपकी स्ट्रिंग के अंदर न हों।

// ✅ Raw string जिसमें # भी एस्केप हो\nlet tricky = r###"स्ट्रिंग जिसमें "कोट्स" और "#" भी है!"###;\nprintln!("{}", tricky);\n

तरीका #4: मल्टीलाइन Raw Strings — जटिल डेटा के लिए कम्बाइन

अब सब कुछ एक साथ जोड़ते हैं। अगर आपको कोट्स, स्लैशेज और इंडेंटेशन के साथ मल्टीलाइन टेक्स्ट लिखना है, तो r#""# का इस्तेमाल करें और लाइन ब्रेक सीधे अंदर डालें: