வகை சுவிட்ச்

ஒரு வகை சுவிட்ச் பல சாத்தியமான வகைகளில் பாகுபாடு காட்டுகிறது இடைமுக மதிப்பு. இது 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 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+ வகைகள் → வகை சுவிட்ச்.