Type Switch

Teil des Abschnitts Logik & Ablauf der GO-Journey von Coddy — Lektion 18 von 68.

Während Type Assertions gut funktionieren, um einen einzelnen Typ zu prüfen, müssen Sie oft mehrere mögliche Typen für eine Interface-Variable verarbeiten. Hier wird ein Type Switch unglaublich nützlich – er bietet eine saubere Möglichkeit, verschiedene Aktionen basierend auf dem konkreten Typ auszuführen.

Ein Type-Switch verwendet diese spezielle Syntax: switch v := i.(type). Beachten Sie das (type) Schlüsselwort anstelle eines spezifischen Typs. Die Variable v wird in jedem Fall den tatsächlichen Wert mit seinem konkreten Typ enthalten:

func describe(data interface{}) {
    switch v := data.(type) {
    case int:
        fmt.Printf("Integer: %d\n", v)
    case string:
        fmt.Printf("String: %s\n", v)
    case bool:
        fmt.Printf("Boolean: %t\n", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

In jedem Fall hat v automatisch den richtigen Typ – es ist keine zusätzliche Typzusicherung erforderlich. Dies macht Type-Switches wesentlich übersichtlicher als das Verketten mehrerer Typzusicherungen mit if-else-Anweisungen, insbesondere wenn Sie mehrere verschiedene Typen an einer Stelle behandeln müssen.

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Aufgabe

Einfach

In dieser Herausforderung üben Sie die Verwendung von Type Switches, um mehrere Datentypen in einem Benachrichtigungssystem zu verarbeiten. Sie erstellen eine Funktion, die verschiedene Arten von Benachrichtigungen verarbeitet und sie basierend auf ihrem konkreten Typ angemessen formatiert.

Sie erhalten zwei Eingaben:

Einen String, der den Benachrichtigungstyp darstellt (z. B. "email", "sms", "push" oder "alert")
Einen String, der den Inhalt oder Wert der Benachrichtigung darstellt

Ihre Aufgabe ist es:

Erstellen Sie eine Funktion namens processNotification, die einen interface{}-Parameter entgegennimmt
Konvertieren Sie basierend auf der Eingabe des Benachrichtigungstyps den Inhalt in den entsprechenden Go-Typ und speichern Sie ihn in einer interface{}-Variablen:
- Für "email": Verwenden Sie den Inhalt als string
- Für "sms": Konvertieren Sie den Inhalt in einen integer (der die Zeichenanzahl darstellt)
- Für "push": Konvertieren Sie den Inhalt in einen boolean (true für "enabled", false für alles andere)
- Für "alert": Konvertieren Sie den Inhalt in einen float64 (der die Prioritätsstufe darstellt)
Rufen Sie die Funktion processNotification mit dem konvertierten Wert auf
Verwenden Sie innerhalb von processNotification einen Type Switch, um jeden Typ zu behandeln und die entsprechende Nachricht auszugeben:
- Für string: "Email notification: [value]"
- Für int: "SMS notification with [value] characters"
- Für bool: "Push notifications: [value]"
- Für float64: "Alert with priority: [value]"
- Für jeden anderen Typ: "Unknown notification type"

Verwenden Sie das strconv-Paket für String-Konvertierungen. Für die boolesche Konvertierung sollte nur "enabled" zu true führen. Diese Herausforderung zeigt, wie Type Switches eine saubere Möglichkeit bieten, mehrere Typen in einer einzigen Kontrollstruktur zu verarbeiten, wobei Sie in jedem Fall automatisch den korrekt typisierten Wert erhalten.

Spickzettel

Ein Type-Switch bietet eine saubere Möglichkeit, mehrere mögliche Typen für eine Interface-Variable mit der Syntax switch v := i.(type) zu verarbeiten:

func describe(data interface{}) {
    switch v := data.(type) {
    case int:
        fmt.Printf("Integer: %d\n", v)
    case string:
        fmt.Printf("String: %s\n", v)
    case bool:
        fmt.Printf("Boolean: %t\n", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

In jedem Fall hat die Variable v automatisch den korrekten konkreten Typ, wodurch zusätzliche Type-Assertions überflüssig werden.

Probier es selbst

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// Eingabe lesen
	var notificationType string
	var content string
	fmt.Scanln(&notificationType)
	fmt.Scanln(&content)
	
	// TODO: Schreiben Sie Ihren Code unten
	// 1. Erstellen Sie die Funktion processNotification, die einen interface{}-Parameter entgegennimmt
	// 2. Konvertieren Sie den Inhalt basierend auf notificationType in den entsprechenden Typ
	// 3. Rufen Sie processNotification mit dem konvertierten Wert auf
	// 4. Verwenden Sie einen Type Switch innerhalb von processNotification, um verschiedene Typen zu verarbeiten
	
}

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.