Go में := और = में अंतर: पूरी गाइड उदाहरण सहित

परिचय: := और = में भ्रम आपका Go कोड कैसे तोड़ सकता है

आप Go में कोड लिख रहे हैं, सब कुछ ठीक चल रहा है, लेकिन अचानक कंपाइलर एरर देता है no new variables on left side of :=. परिचित लग रहा है? या फिर आप किसी सहकर्मी का कोड देखते हैं जहाँ वह कभी = तो कभी := इस्तेमाल करता है, और लगता है कि कोई फर्क नहीं है। असल में, इनमें बुनियादी अंतर है, और इसे न समझना Golang में शुरुआती लोगों की सबसे आम गलतियों में से एक है।

इस गाइड में, हम समझेंगे कि := (short variable declaration) और = (assignment) ऑपरेटरों में क्या अंतर है। आप जानेंगे कि कब किसका उपयोग करना है, गलतियों से कैसे बचना है, और Go में साफ और इडियोमैटिक कोड कैसे लिखना है। चलिए शुरू करते हैं!

बुनियादी बातें: वेरिएबल क्या हैं और इनकी ज़रूरत क्यों है?

ऑपरेटरों की गहराई में जाने से पहले, याद कर लें कि वेरिएबल मेमोरी का एक नामित क्षेत्र होता है जहाँ एक निश्चित प्रकार का मान स्टोर होता है। Go में, किसी भी स्ट्रिक्टली टाइप की गई भाषा की तरह, वेरिएबल के साथ सावधानी से काम करना ज़रूरी है।

ऑपरेटर := और = वेरिएबल के साथ इंटरैक्ट करने के दो तरीके हैं, लेकिन ये अलग-अलग काम करते हैं। पहला वेरिएबल को डिक्लेयर करता है, दूसरा उसके मान को बदलता है।

= ऑपरेटर (असाइनमेंट): केवल बदलाव, डिक्लेरेशन नहीं

= ऑपरेटर क्लासिक असाइनमेंट है। यह पहले से मौजूद वेरिएबल को लेता है और उसमें नया मान डालता है। अगर वेरिएबल मौजूद नहीं है, तो कंपाइलर एरर देगा।

package main\n\nimport "fmt"\n\nfunc main() {\n    var name string  // वेरिएबल को स्पष्ट रूप से डिक्लेयर किया\n    name = "Go"      // मान असाइन किया (काम करेगा)\n    fmt.Println(name)\n\n    // age = 10       // एरर: वेरिएबल age डिक्लेयर नहीं हुआ\n}\n

यहाँ name को var से डिक्लेयर किया गया था, इसलिए हम = का उपयोग कर सकते हैं। अगर हम बिना डिक्लेरेशन के age = 10 लिखने की कोशिश करते, तो कंपाइलर कोड को कंपाइल करने से मना कर देता।

= का उपयोग कब करें?

\n
• जब वेरिएबल पहले से डिक्लेयर हो (var या := के ज़रिए)।
\n
• लूप और इटरेशन में काउंटर अपडेट करने के लिए।
\n
• पॉइंटर्स और स्ट्रक्चर के साथ काम करते समय, जहाँ फ़ील्ड बदलना हो।
\n

:= ऑपरेटर (शॉर्ट डिक्लेरेशन): एक साथ डिक्लेरेशन और असाइनमेंट

:= ऑपरेटर "सिंटैक्स शुगर" है जो एक साथ वेरिएबल को डिक्लेयर करता है और उसे मान असाइन करता है। वेरिएबल का टाइप दाईं ओर के एक्सप्रेशन से ऑटोमैटिकली पता चल जाता है। यह var x int = 5 लिखने से कहीं ज़्यादा छोटा है।

package main\n\nimport "fmt"\n\nfunc main() {\n    name := "Go"   // डिक्लेयर और असाइन, टाइप string\n    age := 10      // डिक्लेयर और असाइन, टाइप int\n    fmt.Println(name, age)\n}\n

यह इसके बराबर है:

var name string = "Go"\nvar age int = 10\n

लेकिन := छोटा है और पढ़ने में आसान है। मुख्य नियम: := के बाईं ओर कम से कम एक नया वेरिएबल होना चाहिए। अगर सभी वेरिएबल पहले से डिक्लेयर हैं, तो आपको एरर मिलेगा।

:= का उपयोग कब करें?

\n
• फंक्शन के अंदर लोकल वेरिएबल डिक्लेयर करने के लिए।
\n
• for, if और switch लूप में शॉर्ट इनिशियलाइज़ेशन के लिए।
\n
• उन फंक्शन के साथ काम करते समय जो कई मान रिटर्न करते हैं (जैसे, err := someFunc())।
\n

मुख्य अंतर: डिक्लेरेशन बनाम बदलाव

सबसे ज़रूरी अंतर जो याद रखना चाहिए:

\n
• := — यह डिक्लेरेशन है। यह मौजूदा स्कोप में एक नया वेरिएबल बनाता है।
\n
• = — यह असाइनमेंट है। यह मौजूदा वेरिएबल के मान को बदलता है।
\n

इसे वेरिएबल के "जन्म" और "नाम बदलने" के बीच के अंतर की तरह समझें। आप किसी ऐसी चीज़ का नाम नहीं बदल सकते जो अस्तित्व में ही नहीं है।