Type Switch

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

Während Typzusicherungen sich gut zur Überprüfung eines einzelnen Typs eignen, musst du häufig mehrere mögliche Typen für eine Interface-Variable behandeln. Hier ist ein Typswitch äußerst nützlich – er bietet eine übersichtliche Möglichkeit, je nach konkretem Typ unterschiedliche Aktionen auszuführen.

Eine Typumschaltung verwendet diese besondere Syntax: switch v := i.(type). Beachte das Schlüsselwort (type) anstelle eines bestimmten Typs. Die Variable v enthält in jedem Fall den tatsächlichen Wert mit seinem konkreten Typ:

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 – eine zusätzliche Typumwandlung ist nicht erforderlich. Dadurch sind Typschalter deutlich übersichtlicher als mehrere Typumwandlungen in einer Kette mit if-else-Anweisungen, besonders wenn du an einer Stelle mehrere verschiedene Typen behandeln musst.

Aufgabe

Einfach

In dieser Herausforderung übst du, Typumschaltungen zu verwenden, um mehrere Datentypen in einem Benachrichtigungssystem zu verarbeiten. Du erstellst eine Funktion, die verschiedene Arten von Benachrichtigungen verarbeitet und sie entsprechend ihrem konkreten Typ formatiert.

Du erhältst zwei Eingaben:

Eine Zeichenfolge, die den Benachrichtigungstyp darstellt (z. B. "email", "sms", "push" oder "alert")
Eine Zeichenfolge, die den Inhalt oder Wert der Benachrichtigung darstellt

Deine Aufgabe ist es:

Eine Funktion namens processNotification zu erstellen, die einen interface{}-Parameter entgegennimmt
Den Inhalt anhand der Eingabe für den Benachrichtigungstyp in den entsprechenden Go-Typ umzuwandeln und in einer interface{}-Variable zu speichern:
- Für "email": den Inhalt als Zeichenfolge verwenden
- Für "sms": den Inhalt in eine Ganzzahl umwandeln (die die Zeichenanzahl darstellt)
- Für "push": den Inhalt in einen booleschen Wert umwandeln (true für "enabled", false für alles andere)
- Für "alert": den Inhalt in einen float64-Wert umwandeln (der die Prioritätsstufe darstellt)
Die Funktion processNotification mit dem umgewandelten Wert aufzurufen
In processNotification eine Typumschaltung zu verwenden, um jeden Typ zu verarbeiten und die passende Meldung 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 alle anderen Typen: "Unknown notification type"

Verwende das Paket strconv für die Umwandlung von Zeichenfolgen. Bei der Umwandlung in einen booleschen Wert soll nur "enabled" zu true führen. Diese Herausforderung zeigt, wie Typumschaltungen eine übersichtliche Möglichkeit bieten, mehrere Typen in einer einzigen Kontrollstruktur zu verarbeiten und dir in jedem Fall automatisch den korrekt typisierten Wert bereitzustellen.

Gib float64 in seiner kürzesten Form aus, so wie es fmt.Println oder die Formate %v / %g tun: 3.5 wird als 3.5 und 1.0 als 1 ausgegeben (das Format %f würde 1.000000 ausgeben).

Probier es selbst

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// Eingabe einlesen
	var notificationType string
	var content string
	fmt.Scanln(&notificationType)
	fmt.Scanln(&content)
	
	// TODO: Schreibe deinen Code unten
	// 1. Erstelle die Funktion processNotification, die einen Parameter vom Typ interface{} entgegennimmt
	// 2. Konvertiere content anhand von notificationType in den passenden Typ
	// 3. Rufe processNotification mit dem konvertierten Wert auf
	// 4. Verwende einen Type-Switch innerhalb von processNotification, um verschiedene Typen zu verarbeiten
	
}