मुहावरेदार स्विच

गो का switch C/Java की तुलना में अधिक एर्गोनोमिक है: प्रत्येक case का अपना है स्वयं का अंतर्निहित ब्लॉक (लिखने के लिए कोई break नहीं), आप समूह बना सकते हैं अल्पविराम के साथ एकाधिक मान, और switch बिना किसी अभिव्यक्ति के व्यवहार करते हैं अधिक पठनीय if/else if श्रृंखला की तरह।

किसी मान पर स्विच करें

giorno := "mar"
switch giorno {
case "lun", "mar", "mer", "gio", "ven":
    fmt.Println("feriale")
case "sab", "dom":
    fmt.Println("weekend")
default:
    fmt.Println("sconosciuto")
}

case अल्पविराम से अलग किए गए एकाधिक मानों को स्वीकार करता है और कोई अंतर्निहित नहीं है फॉलथ्रू: जैसे ही कोई मामला निष्पादित होता है, स्विच बाहर निकल जाता है।

बिना किसी शर्त के स्विच करें

यदि आप अभिव्यक्ति को छोड़ देते हैं, तो स्विच true का मूल्यांकन करता है और प्रत्येक case एक है bool स्थिति. यह लंबी if/else if श्रृंखलाओं का मुहावरेदार विकल्प है:

switch {
case x < 0:
    fmt.Println("negativo")
case x == 0:
    fmt.Println("zero")
case x < 10:
    fmt.Println("piccolo")
default:
    fmt.Println("grande")
}

आरंभ कथन

if की तरह, switch भी एक init कथन स्वीकार करता है:

switch n := len(s); {
case n == 0:
    fmt.Println("vuoto")
case n > 100:
    fmt.Println("lungo")
default:
    fmt.Println("ok")
}

n केवल स्विच के अंदर मौजूद है।

स्पष्ट fallthrough

यदि आप वास्तव में चाहते हैं कि निष्पादन अगले मामले में हो, तो आपको इसे लिखना होगा:

switch 1 {
case 1:
    fmt.Println("uno")
    fallthrough
case 2:
    fmt.Println("due")  // anche questo viene stampato
case 3:
    fmt.Println("tre")  // questo no
}

प्रकार स्विच (पूर्वावलोकन)

यह आपको इंटरफ़ेस के गतिशील प्रकार के आधार पर भेदभाव करने देता है मूल्य. हम इसे इंटरफ़ेस मॉड्यूल में गहराई से कवर करेंगे:

var i interface{} = "ciao"
switch v := i.(type) {
case int:
    fmt.Println("int:", v)
case string:
    fmt.Println("string:", v)
default:
    fmt.Printf("tipo %T\n", v)
}

इसे अजमाएं

switch 1 {
case 1:
    fmt.Print("a")
case 2:
    fmt.Print("b")
}

संक्षिप्त

• case अल्पविराम द्वारा अलग किए गए एकाधिक मान स्वीकार करता है।
• कोई अंतर्निहित गिरावट नहीं: प्रत्येक मामले का अपना अंतर्निहित break होता है।
• switch { ... } बिना किसी अभिव्यक्ति के = एक अधिक पठनीय if/else if श्रृंखला।
• इनिट स्टेटमेंट: switch x := f(); { ... }, दायरा ब्लॉक तक सीमित है।
• fallthrough मौजूद है लेकिन दुर्लभ है; इसकी स्थिति का मूल्यांकन किए बिना अगले मामले में प्रवेश करता है।
• गतिशील प्रकार (इंटरफ़ेस मॉड्यूल) के आधार पर भेदभाव करने के लिए स्विच v := i.(type) टाइप करें।