నిరూపణ రకం

ఇంటర్‌ఫేస్ విలువ నుండి కాంక్రీట్ రకాన్ని సంగ్రహిస్తుంది రకం నిరూపణ. మీకు 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, కాల్ క్లోజ్ ఎట్ ఎట్".

పాయింటర్స్ vs విలువలపై అస్సర్షన్

ప్రకటన ఖచ్చితంగా డైనమిక్ రకంతో సరిపోలాలి:

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 రకం సిస్టమ్‌కు ప్రత్యేక రకాలు.

అసెర్షన్ vs టైప్ స్విచ్‌ను ఎప్పుడు ఉపయోగించాలి

• కేవలం 1 సాధ్యమయ్యే రకం, "ఫీచర్-డిటెక్ట్" చెక్ (ఉదా. ఐచ్ఛిక ఇంటర్‌ఫేస్‌కు ప్రసారం చేయబడింది): రకం ధృవీకరణ comma okతో.
• 2+ సాధ్యమయ్యే రకాలు, బహుళ శాఖలపై పంపండి: రకం స్విచ్ (తదుపరి పాఠం).

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

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

రీక్యాప్

• v := i.(T): డైనమిక్ రకం ≠ T అయితే భయపడండి.
• v, ok := i.(T): సురక్షిత నమూనా, okని తనిఖీ చేయండి.
• మరొక ఇంటర్‌ఫేస్‌కు వ్యతిరేకంగా కూడా పనిచేస్తుంది ("ఫీచర్ డిటెక్ట్").
• T మరియు *T ధృవీకరణ కోసం విభిన్న రకాలు.
• 1 రకం → ప్రకటన; 2+ రకాలు → రకం స్విచ్.