Type-Assertion in

Über Type-Assertion

Interfaces in Go können zu Unklarheit über den zugrunde liegenden Typ führen. Tatsächlich kann das leere Interface jeden beliebigen konkreten Wert annehmen (auch primitive Werte). Mit einer Type Assertion holen wir den zugrunde liegenden konkreten Wert aus einem Interface-Wert heraus. Die Syntax dafür sieht so aus: interfaceVariable.(concreteType).

Weisen wir das Ergebnis dieser Anweisung einer einzelnen Variable zu, behaupten wir, dass die Interface-Variable einen Wert des konkreten Typs enthält. Dadurch kann zur Laufzeit eine Panic auftreten, wenn der Interface-Wert nicht den angegebenen konkreten Typ hat. Zum Beispiel:

var input interface{} = 12
str := input.(string) // panic at runtime since input is not a string!

Wir können prüfen, ob ein Interface-Wert einen bestimmten konkreten Typ enthält, indem wir beide Rückgabewerte der Type Assertion nutzen: den zugrunde liegenden Wert und einen booleschen Wert, der angibt, ob die Type Assertion erfolgreich war. Zum Beispiel:

str, ok := input.(string) // no panic if input is not a string

Enthält input einen string, dann ist str der zugrunde liegende Wert und ok ist wahr. Enthält input keinen string, dann ist str der Nullwert vom Typ string (also "", der leere String) und ok ist falsch. In keinem Fall tritt eine Panic auf.

Häufig sieht man dieses Idiom:

str, ok := input.(string)
if !ok {
    str = "a default value"
}

Type Switches

Ein Type Switch kann mehrere Type Assertions hintereinander ausführen. Er hat dieselbe Syntax wie eine Type Assertion (interfaceVariable.(concreteType)), verwendet aber statt eines bestimmten concreteType das Schlüsselwort type. Hier ist ein Beispiel:

var i interface{} = 12 // try: 12.3, true, int64(12), []int{}, map[string]int{}

switch v := i.(type) {
case int:
    fmt.Printf("the integer %d\n", v)
case string:
    fmt.Printf("the string %s\n", v)
default:
    fmt.Printf("type, %T, not handled explicitly: %#v\n", v, v)
}