अभिकथन टाइप करें

एक प्रकार का अभिकथन एक इंटरफ़ेस मान से ठोस प्रकार निकालता है। आपको इसकी आवश्यकता तब होती है जब आपके पास interface{} (या "उच्च" इंटरफ़ेस) होता है हाथ और फ़ील्ड तक पहुंचने के लिए इसे अपने विशिष्ट प्रकार के रूप में मानने की आवश्यकता है इंटरफ़ेस पर विधियाँ मौजूद नहीं हैं.

सिंटेक्स

var i interface{} = "ciao"

s := i.(string)           // "panic" form: panics if it's not a string
s, ok := i.(string)       // "comma ok" form: ok = false if it's not a string

दो रूप, दो शब्दार्थ:

"अल्पविराम ठीक है" फ़ॉर्म: सबसे सुरक्षित

var i interface{} = 42

if s, ok := i.(string); ok {
    fmt.Println("è stringa:", s)
} else {
    fmt.Println("non è stringa, ignoro")
}

ok आपको बिना घबराए "गलत प्रकार" के मामले को संभालने की सुविधा देता है। यह है अधिकांश मामलों में मुहावरेदार पैटर्न।

एक इंटरफ़ेस पर दावा

यह दावा केवल ठोस प्रकारों पर ही नहीं, बल्कि अन्य प्रकारों पर भी काम करता है इंटरफ़ेस:

type Closer interface { Close() error }

func tryClose(x interface{}) {
    if c, ok := x.(Closer); ok {
        c.Close()
    }
}

मानक लाइब्रेरी में एक बहुत ही सामान्य पैटर्न: "यदि मेरा इनपुट भी है एक io.Closer, अंत में बंद करें पर कॉल करें"।

सूचक बनाम मूल्यों पर अभिकथन

दावा बिल्कुल गतिशील प्रकार से मेल खाना चाहिए:

type Cat struct{}
func (c *Cat) Meow() {}

var a interface{} = &Cat{}

c1, ok := a.(*Cat)   // ok = true
c2, ok := a.(Cat)    // ok = false: it holds *Cat, not Cat

*Cat और Cat टाइप सिस्टम के लिए अलग-अलग प्रकार हैं।

अभिकथन बनाम प्रकार स्विच का उपयोग कब करें

• केवल 1 संभावित प्रकार, "फीचर-डिटेक्ट" चेक (उदाहरण के लिए एक वैकल्पिक इंटरफ़ेस पर कास्ट): प्रकार का दावा comma ok के साथ।
• 2+ संभावित प्रकार, एकाधिक शाखाओं पर प्रेषण: प्रकार स्विच (अगला पाठ)।

इसे अजमाएं

var i interface{} = 42
s := i.(string)

संक्षिप्त

• v := i.(T): यदि गतिशील प्रकार ≠ T है तो घबराएं।
• v, ok := i.(T): सुरक्षित पैटर्न, ok जांचें।
• किसी अन्य इंटरफ़ेस ("फ़ीचर डिटेक्ट") के विरुद्ध भी काम करता है।
• T और *T दावे के लिए अलग-अलग प्रकार हैं।
• 1 प्रकार → दावा; 2+ प्रकार → प्रकार स्विच।