స్విచ్ టైప్ చేయండి

ఒక రకం స్విచ్ బహుళ సాధ్యమయ్యే రకాలైన వాటి మధ్య వివక్ష చూపుతుంది ఇంటర్ఫేస్ విలువ. ఇది ఉన్నప్పుడు 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 స్వయంగా అంతర్గతంగా ఒక రకం స్విచ్‌ని నిర్వహించడానికి ఉపయోగిస్తుంది ప్రామాణిక ఫార్మాట్‌లు.

రకం స్విచ్ vs ప్రతిబింబం

తెలిసిన కొన్ని రకాల → రకం స్విచ్ (ఫాస్ట్, రీడబుల్) కోసం. తెలియని రకాల డైనమిక్ తనిఖీ కోసం → reflect ప్యాకేజీ (మరిన్ని శక్తివంతమైనది కానీ నెమ్మదిగా మరియు మరింత వెర్బోస్).

దీనిని ప్రయత్నించండి

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

రీక్యాప్

• switch v := i.(type) { case T: ... }: డైనమిక్ రకంపై వివక్ష చూపుతుంది.
• సింగిల్-టైప్ కేస్ లోపల, v కేస్ రకాన్ని కలిగి ఉంది.
• case T1, T2: v అసలు ఇంటర్‌ఫేస్ రకాన్ని ఉంచుతుంది.
• default నిర్వహించని కేసుల కోసం; నిల్ ఇంటర్‌ఫేస్ కోసం case nil.
• రకం స్విచ్‌లలో fallthrough లేదు.
• 1 రకం → రకం ప్రకటన; 2+ రకాలు → రకం స్విచ్.