टाइप एसर्शन में

टाइप एसर्शन के बारे में

Go में इंटरफेस अंतर्निहित टाइप को लेकर अस्पष्टता पैदा कर सकते हैं। वास्तव में, खाली इंटरफेस किसी भी कंक्रीट वैल्यू को ले सकता है (प्रिमिटिव सहित)। टाइप एसर्शन की मदद से हम इस सिंटैक्स का इस्तेमाल करके इंटरफेस वैल्यू की अंतर्निहित कंक्रीट वैल्यू निकाल सकते हैं: interfaceVariable.(concreteType).

अगर हम इस स्टेटमेंट के परिणाम को एक ही वैल्यू में असाइन करते हैं, तो हम दावा करते हैं कि इंटरफेस वेरिएबल में कंक्रीट टाइप की वैल्यू होती है। परिणाम यह है कि अगर इंटरफेस वैल्यू में बताया गया कंक्रीट टाइप नहीं है, तो रनटाइम पर पैनिक हो सकता है। उदाहरण के लिए:

var input interface{} = 12
str := input.(string) // panic at runtime since input is not a string!

हम यह जाँच सकते हैं कि किसी इंटरफेस वैल्यू में कोई खास कंक्रीट टाइप है या नहीं। इसके लिए हम टाइप एसर्शन की दोनों रिटर्न वैल्यू इस्तेमाल करते हैं: अंतर्निहित वैल्यू, और एक बूलियन वैल्यू जो बताती है कि एसर्शन सफल हुआ या नहीं। उदाहरण के लिए:

str, ok := input.(string) // no panic if input is not a string

अगर input में string है, तो str अंतर्निहित वैल्यू होगी और ok की वैल्यू सही होगी। अगर input में string नहीं है, तो str टाइप string की शून्य वैल्यू होगी (यानी "", खाली स्ट्रिंग) और ok की वैल्यू गलत होगी। किसी भी स्थिति में पैनिक नहीं होता।

इस तरह का आइडियम अक्सर देखने को मिलता है:

str, ok := input.(string)
if !ok {
    str = "a default value"
}

टाइप स्विच

एक टाइप स्विच एक के बाद एक कई टाइप एसर्शन कर सकता है। इसका सिंटैक्स टाइप एसर्शन (interfaceVariable.(concreteType)) जैसा ही होता है, लेकिन किसी खास concreteType की जगह यह type कीवर्ड का इस्तेमाल करता है। यहाँ एक उदाहरण है:

var i interface{} = 12 // try: 12.3, true, int64(12), []int{}, map[string]int{}

switch v := i.(type) {
case int:
    fmt.Printf("the integer %d\n", v)
case string:
    fmt.Printf("the string %s\n", v)
default:
    fmt.Printf("type, %T, not handled explicitly: %#v\n", v, v)
}