Go में मल्टी-लाइन स्ट्रिंग्स: 5 घातक गलतियाँ और उनसे कैसे बचें

Go में मल्टी-लाइन स्ट्रिंग्स: वे जाल जो अनुभवी डेवलपर्स को भी फंसा सकते हैं

एक स्थिति की कल्पना करें: आप Go में SQL क्वेरी, JSON टेम्पलेट, या बस लॉग के लिए एक लंबा संदेश लिख रहे हैं। आप सहज रूप से लाइन को तोड़ने के लिए Enter दबाते हैं, और... कंपाइलर एक त्रुटि देता है। परिचित लगता है? Stack Overflow पर "How do you write multiline strings in Go?" प्रश्न ने हज़ारों व्यूज़ एकत्र किए हैं, यह कोई संयोग नहीं है। यह उन छोटी-छोटी चीजों में से एक है जो उन लोगों को भी भ्रमित कर सकती है जिन्होंने भाषा के सिंटैक्स में महारत हासिल कर ली है।

इस लेख में, हम Go में मल्टी-लाइन स्ट्रिंग्स के साथ काम करते समय शीर्ष 5 घातक गलतियों का विश्लेषण करेंगे और दिखाएंगे कि उनसे कैसे बचा जाए। आप जानेंगे कि इंटरप्रेटेड और रॉ लिटरल में क्या अंतर है, क्यों एक अतिरिक्त स्पेस आपका दिन खराब कर सकता है, और कोड को सही तरीके से कैसे फॉर्मेट किया जाए। चलिए शुरू करते हैं!

गलती #1: मल्टी-लाइन टेक्स्ट के लिए डबल कोट्स का उपयोग करना

शुरुआती लोगों की सबसे आम गलती डबल कोट्स (") के अंदर मल्टी-लाइन स्ट्रिंग लिखने का प्रयास करना है। Go में, डबल कोट्स एक इंटरप्रेटेड स्ट्रिंग लिटरल बनाते हैं। इसका मतलब है कि उनके अंदर न्यूलाइन कैरेक्टर निषिद्ध है।

// यह कोड कंपाइल नहीं होगा\npackage main\n\nimport "fmt"\n\nfunc main() {\n    // त्रुटि: unexpected newline in string literal\n    message := "नमस्ते,\n    दुनिया!"\n    fmt.Println(message)\n}\n

Go कंपाइलर सख्त है: वह एक बंद न हुआ कोट और एक न्यूलाइन कैरेक्टर देखता है, जो सिंटैक्स त्रुटि का कारण बनता है। याद रखें: डबल कोट्स केवल एकल-पंक्ति स्ट्रिंग्स के लिए हैं।

गलती #2: रॉ स्ट्रिंग लिटरल (raw string literals) को अनदेखा करना

मल्टी-लाइन समस्या का समाधान रॉ स्ट्रिंग लिटरल है। वे बैकटिक्स (`) का उपयोग करके बनाए जाते हैं। उनके अंदर सभी कैरेक्टर को शाब्दिक रूप से इंटरप्रेट किया जाता है, जिसमें न्यूलाइन, टैब और बैकस्लैश भी शामिल हैं।

// सही तरीका: बैकटिक्स का उपयोग करें\npackage main\n\nimport "fmt"\n\nfunc main() {\n    message := `नमस्ते,\nदुनिया!`\n    fmt.Println(message)\n}\n// आउटपुट:\n// नमस्ते,\n// दुनिया!\n

यह SQL क्वेरी, JSON, HTML टेम्पलेट और किसी भी अन्य टेक्स्ट के लिए एक आदर्श विकल्प है जहाँ संरचना महत्वपूर्ण है। हालाँकि, यहाँ एक और गलती छिपी हुई है।

गलती #3: रॉ स्ट्रिंग्स के अंदर अतिरिक्त स्पेस और इंडेंटेशन

जब आप कोड लिखते हैं, तो आप पठनीयता के लिए इसे इंडेंट करते हैं। लेकिन यदि आप मल्टी-लाइन स्ट्रिंग को इंडेंटेशन के साथ सीधे फंक्शन के अंदर डालते हैं, तो ये इंडेंटेशन स्ट्रिंग का हिस्सा बन जाएंगे।

// "अतिरिक्त" स्पेस वाला उदाहरण\npackage main\n\nimport "fmt"\n\nfunc main() {\n    query := `\n        SELECT id, name\n        FROM users\n        WHERE active = true\n    `\n    fmt.Println(query)\n}\n// आउटपुट (लीडिंग स्पेस पर ध्यान दें):\n//\n//         SELECT id, name\n//         FROM users\n//         WHERE active = true\n//     \n

आउटपुट की पहली पंक्ति खाली है (क्योंकि ओपनिंग बैकटिक के बाद न्यूलाइन है), और प्रत्येक अगली पंक्ति 8 स्पेस से शुरू होती है। यह लॉजिक को तोड़ सकता है यदि स्ट्रिंग का उपयोग, उदाहरण के लिए, os.Exec में या तुलना में किया जाता है।

इससे कैसे बचें? दो तरीके हैं। पहला - स्ट्रिंग को बिना इंडेंटेशन के, किनारे से सटाकर लिखें:

query := `SELECT id, name\nFROM users\nWHERE active = true`\n

दूसरा - कॉन्केटनेशन या strings.TrimSpace का उपयोग करें। लेकिन सबसे आसान तरीका है कि यदि वे महत्वपूर्ण हैं तो रॉ स्ट्रिंग्स के अंदर इंडेंटेशन न करने की आदत डालें। SQL क्वेरी के लिए यह अक्सर कोई समस्या नहीं होती, लेकिन लॉग या उपयोगकर्ता संदेशों के लिए यह घातक हो सकता है।

गलती #4: रॉ स्ट्रिंग्स में एस्केपिंग के बारे में भूल जाना

रॉ स्ट्रिंग्स escape-sequences को सपोर्ट नहीं करती हैं। इसका मतलब है कि बैकटिक्स के अंदर \\n सिर्फ दो कैरेक्टर हैं: एक बैकस्लैश और अक्षर 'n', न कि न्यूलाइन।

package main\n\nimport "fmt"