Go में ऑब्जेक्ट का प्रकार कैसे पता करें: शुरुआती की 5 घातक गलतियाँ और उनसे बचने के तरीके

परिचय: "यह कैसा जानवर है?"

कल्पना करें: आप Go में एक फ़ंक्शन लिख रहे हैं जो interface{} स्वीकार करता है। इस फ़ंक्शन के अंदर, आप यह समझना चाहते हैं कि आपके पास किस प्रकार का डेटा आया है। संख्या? स्ट्रिंग? या शायद कोई कस्टम स्ट्रक्चर? यदि आप Python या JavaScript से आए हैं, जहाँ एक पंक्ति में प्रकार का पता लगाया जा सकता है (type() या typeof), तो Go में आपके लिए एक छोटा सा आश्चर्य है। Go एक सख्त टाइपिंग वाली भाषा है, और आप आसानी से किसी ऑब्जेक्ट के प्रकार को "महसूस" नहीं कर सकते।

Stack Overflow पर प्रश्न "How to find the type of an object in Go?" ने हजारों बार देखा गया है। इसका मतलब है कि अनुभवी डेवलपर्स भी कभी-कभी भ्रमित हो जाते हैं। इस लेख में, हम शीर्ष गलतियों पर चर्चा करेंगे जो शुरुआती (और न केवल) Go में प्रकार निर्धारित करते समय करते हैं, और दिखाएंगे कि उनसे कैसे बचा जाए। आप reflect.TypeOf, fmt.Sprintf के साथ %T, type assertion और type switch के बारे में जानेंगे।

विधि #1: सबसे सरल — fmt और %T (लेकिन एक पेच के साथ)

प्रकार जानने का सबसे तेज़ तरीका पैकेज fmt और फ़ॉर्मेट %T का उपयोग करना है। यह काम करता है, लेकिन कई लोग भूल जाते हैं कि fmt कोई जादू की छड़ी नहीं है, बल्कि reflect के ऊपर एक आवरण मात्र है।

package main\n\nimport "fmt"\n\nfunc main() {\n    var x interface{} = 42\n    fmt.Printf("प्रकार: %T\\n", x) // प्रकार: int\n\n    var s interface{} = "hello"\n    fmt.Printf("प्रकार: %T\\n", s) // प्रकार: string\n}\n

सरल है, है ना? लेकिन यहाँ गलती यह है: %T एक स्ट्रिंग लौटाता है, प्रकार नहीं। आप इसके साथ स्क्रीन पर प्रदर्शित करने के अलावा कोई अन्य कार्य नहीं कर सकते। यदि आपको यह जाँचने की आवश्यकता है कि ऑब्जेक्ट एक संख्या है या नहीं, और कुछ करना है — तो %T आपकी मदद नहीं करेगा। यह पहली गलती है: %T का उपयोग वहाँ करना जहाँ शाखाकरण तर्क की आवश्यकता है।

कैसे बचें

%T का उपयोग केवल डिबगिंग या लॉग आउटपुट के लिए करें। कोड में प्रकारों की जाँच के लिए type assertion या type switch का उपयोग करें (उनके बारे में नीचे)।

विधि #2: reflect पैकेज — शक्तिशाली, लेकिन खतरनाक

reflect पैकेज Go में रिफ्लेक्शन के लिए एक सज्जन व्यक्ति का सेट है। सबसे लोकप्रिय विधि reflect.TypeOf() है।

package main\n\nimport (\n    "fmt"\n    "reflect"\n)\n\nfunc main() {\n    var x interface{} = 42\n    t := reflect.TypeOf(x)\n    fmt.Println(t) // int\n    fmt.Println(t.Name()) // int\n    fmt.Println(t.Kind()) // int\n}\n

ऐसा लगता है कि यह एक आदर्श समाधान है। लेकिन यहाँ शुरुआती दूसरी गलती करते हैं: वे Kind() और Name() को भ्रमित करते हैं।

\n
• Name() — प्रकार का नाम लौटाता है (उदाहरण के लिए, int, string, MyStruct)।
\n
• Kind() — मूल "प्रकार" लौटाता है (उदाहरण के लिए, int, struct, slice)।
\n

अंतर्निहित प्रकारों के लिए वे समान हैं, लेकिन कस्टम प्रकारों के लिए नहीं। उदाहरण के लिए, यदि आप type MyInt int घोषित करते हैं, तो Name() MyInt लौटाएगा, और Kind() int लौटाएगा। यदि आप केवल Kind() की जाँच करते हैं, तो आप कस्टम प्रकार को छोड़ सकते हैं।

कैसे बचें

हमेशा अपने आप से पूछें: "क्या मेरे लिए सटीक प्रकार महत्वपूर्ण है या केवल श्रेणी?" यदि सटीक प्रकार की आवश्यकता है (उदाहरण के लिए, सीरियलाइज़ेशन के लिए) — Name() का उपयोग करें। यदि केवल यह समझना है कि यह एक संख्या है — Kind() का उपयोग करें।

विधि #3: Type Assertion — शैली का क्लासिक (और पैनिक त्रुटि)

Type assertion (प्रकार का दावा) interface{} से एक विशिष्ट प्रकार "निकालने" का एक तरीका है। यह इस तरह दिखता है:

package main\n\nimport "fmt"\n\nfunc main() {\n    var x interface{} = 42\n    value := x.(int) // दावा करें कि x एक int है\n    fmt.Println(value + 10) // 52\n}\n

गलती क्या है? यदि x निकल