Typ-Assertions und Type-Switches
Sichere Typ-Assertions und Switch-Patterns
Typ-Assertions und Type-Switches ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
Typassertionen
Eine Typassertion extrahiert den konkreten Wert aus einem Interface. Die Syntax lautet x.(T):
package main
import "fmt"
func main() {
var i interface{} = "hello"
s := i.(string) // panics if wrong type
fmt.Println(s, len(s)) // hello 5
}Sichere Assertion mit zwei Werten
Verwenden Sie die Komma-ok-Form, um Panics bei falschen Typen zu vermeiden:
package main
import "fmt"
func main() {
var i interface{} = 42
s, ok := i.(string)
fmt.Println(s, ok) // "" false
n, ok := i.(int)
fmt.Println(n, ok) // 42 true
}Typswitch
Ein Typswitch vergleicht den dynamischen Typ eines Interface-Werts mit mehreren Typen:
package main
import "fmt"
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 bool: return fmt.Sprintf("bool: %v", v)
default: return fmt.Sprintf("unknown: %T", v)
}
}
func main() {
fmt.Println(describe(42))
fmt.Println(describe("hi"))
fmt.Println(describe(3.14))
}Typswitch für error
Typswitches sind besonders nützlich, um Fehler zu kategorisieren:
package main
import ("errors"; "fmt")
type NotFoundError struct{ Name string }
func (e *NotFoundError) Error() string { return e.Name + " not found" }
type PermError struct{}
func (e *PermError) Error() string { return "permission denied" }
func handle(err error) {
switch e := err.(type) {
case *NotFoundError: fmt.Println("missing:", e.Name)
case *PermError: fmt.Println("perm error")
default: fmt.Println("other:", e)
}
}
func main() {
handle(&NotFoundError{"user"})
handle(errors.New("generic"))
}Assertion auf ein Interface
Sie können eine Typassertion auf einen anderen Interface-Typ durchführen, nicht nur auf konkrete Typen. So lässt sich prüfen, ob ein Objekt optionales Verhalten unterstützt:
package main
import "fmt"
type Flusher interface{ Flush() }
type Writer interface{ Write(string) }
type BufferedWriter struct{ buf string }
func (b *BufferedWriter) Write(s string) { b.buf += s }
func (b *BufferedWriter) Flush() { fmt.Println(b.buf); b.buf = "" }
func maybeFlush(w Writer) {
if f, ok := w.(Flusher); ok { f.Flush() }
}
func main() {
bw := &BufferedWriter{}
bw.Write("hello")
maybeFlush(bw)
}Assertion auf ein nil-Interface
Eine Typassertion auf ein nil-Interface löst eine Panic aus. Stellen Sie vor der Assertion immer sicher, dass das Interface nicht nil ist:
package main
import "fmt"
func safePrint(i interface{}) {
if i == nil {
fmt.Println("nil")
return
}
fmt.Printf("%T: %v\n", i, i)
}
func main() {
safePrint(nil)
safePrint(42)
}Alternative zu reflect.TypeOf
Verwenden Sie zum Ausgeben des Typs ohne Assertion fmt.Sprintf("%T", v) oder reflect.TypeOf(v):
package main
import ("fmt"; "reflect")
func main() {
v := []int{1, 2, 3}
fmt.Printf("%T\n", v) // []int
fmt.Println(reflect.TypeOf(v)) // []int
}Type Assertion vs. Konvertierung
Type Assertion: Extrahiert den konkreten Typ aus einem Interface. Type Conversion: Ändert einen konkreten Typ in einen anderen kompatiblen Typ. Es handelt sich um unterschiedliche Operationen:
package main
import "fmt"
func main() {
var i interface{} = int32(5)
n := i.(int32) // assertion — OK
big := int64(n) // conversion — OK
fmt.Println(n, big)
}Comma-ok in select
Das Comma-ok-Muster funktioniert auch beim Empfangen von Channels, um einen geschlossenen Channel zu erkennen. Dasselbe knappe Idiom wird in Go konsequent verwendet.
Wann Type Switches verwendet werden
Häufige Anwendungsfälle:
- JSON-Unmarshaling mit
interface{}-Feldern - Kategorisierung von Fehlern
- Weiterleitung von Protokollnachrichten
- Optionale Prüfung von Interfaces (Flusher, Closer usw.)
Schnelltest
Was ist das Ergebnis einer fehlschlagenden Type Assertion ohne Sicherheitsprüfung?
Zusammenfassung
Die wichtigsten Erkenntnisse:
x.(T)löst bei einem falschen Typ einen Panic aus;x, ok := x.(T)ist sicher- Type Switches behandeln mehrere Typen übersichtlich
- Führen Sie Type Assertions auf Interfaces durch, um optionale Fähigkeiten zu prüfen
- Führen Sie niemals eine Type Assertion auf einem nil-Interface durch
Übungsaufgabe
Schreiben Sie eine Funktion sum(values []any) float64, die einen Type Switch verwendet, um Werte vom Typ int, float64 und string zu verarbeiten (der String soll geparst werden), und andere Werte überspringt.
Häufig gestellte Fragen
Ist die Lektion „Typ-Assertions und Type-Switches“ kostenlos?
Ja — der vollständige Text von „Typ-Assertions und Type-Switches“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Typ-Assertions und Type-Switches“?
Sichere Typ-Assertions und Switch-Patterns Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Go Academy zu starten?
Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Typ-Assertions und Type-Switches“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?
Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Interfaces definieren und implementieren
- Zentrale Interfaces der Standardbibliothek
- Typ-Assertions und Type-Switches
- Interface-Komposition und Best Practices