स्विच टाइप करें

एक प्रकार का स्विच कई संभावित प्रकारों के बीच भेदभाव करता है इंटरफ़ेस मान. यह comma ok का सामान्यीकरण है जब वहाँ होते हैं एक से अधिक मामले.

सिंटेक्स

func describe(i interface{}) string {
    switch v := i.(type) {
    case int:
        return fmt.Sprintf("int %d", v)
    case string:
        return fmt.Sprintf("string %q", v)
    case nil:
        return "nil"
    default:
        return fmt.Sprintf("altro tipo: %T", v)
    }
}

• i.(type) एक विशेष सिंटैक्स है, जो केवल switch के अंदर मान्य है।
• v := ... मान को वर्तमान केस के प्रकार से जोड़ता है: case int के अंदर, v का प्रकार int है।
• default अन्य सभी प्रकारों को पकड़ता है; वहां v में मूल इंटरफ़ेस का प्रकार है।
• case nil शून्य डायनामिक प्रकार वाले इंटरफ़ेस से मेल खाता है।

"नामहीन" मामला

यदि आपको टाइप किए गए मान की आवश्यकता नहीं है, तो आप v को छोड़ सकते हैं:

switch i.(type) {
case int:
    // you know it's an int, but you don't have a variable of that type
case string:
    // ...
}

एक फॉर्म का उपयोग तब किया जाता है जब आपको केवल प्रकार में भेदभाव करने की आवश्यकता होती है, संचालन की नहीं मूल्य पर.

एक ही मामले में अनेक प्रकार

switch v := i.(type) {
case int, int64:
    // here v is still interface{}: the "common" type is just the interface
    fmt.Println("numero intero:", v)
case string:
    // here v is string
    fmt.Println("stringa:", v)
}

विशिष्ट उपयोग मामला: स्वरूपित मुद्रण

func print(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("%d\n", v)
    case string:
        fmt.Printf("%s\n", v)
    case fmt.Stringer:
        fmt.Println(v.String())
    default:
        fmt.Printf("%v\n", v)
    }
}

fmt.Println स्वयं इसे संभालने के लिए आंतरिक रूप से एक प्रकार के स्विच का उपयोग करता है मानक प्रारूप.

प्रकार स्विच बनाम प्रतिबिंब

कुछ ज्ञात प्रकारों के लिए → टाइप स्विच (तेज़, पठनीय)। अज्ञात प्रकारों के गतिशील निरीक्षण के लिए → reflect पैकेज (अधिक) शक्तिशाली लेकिन धीमी और अधिक क्रियात्मक)।

इसे अजमाएं

switch ??? {
  case int: ...
}

संक्षिप्त

• switch v := i.(type) { case T: ... }: गतिशील प्रकार पर भेदभाव करता है।
• एकल-प्रकार के मामले के अंदर, v में मामले का प्रकार होता है।
• case T1, T2: v मूल इंटरफ़ेस का प्रकार रखता है।
• अनसुलझे मामलों के लिए default; शून्य इंटरफ़ेस के लिए case nil।
• टाइप स्विच में कोई fallthrough नहीं।
• 1 प्रकार → प्रकार अभिकथन; 2+ प्रकार → प्रकार स्विच।