Type Switch

Parte de la sección Lógica y Flujo del Journey de GO de Coddy. Lección 18 de 68.

Aunque las aserciones de tipo funcionan bien para comprobar un solo tipo, a menudo necesitas manejar varios tipos posibles para una variable de interfaz. Aquí es donde un type switch resulta increíblemente útil: proporciona una forma clara de realizar distintas acciones según el tipo concreto.

Un switch de tipos utiliza esta sintaxis especial: switch v := i.(type). Observa la palabra clave (type) en lugar de un tipo específico. La variable v contendrá el valor real con su tipo concreto en cada caso:

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)
    }
}

En cada case, v tiene automáticamente el tipo correcto; no se necesita ninguna aserción de tipo adicional. Esto hace que los type switches sean mucho más limpios que encadenar varias aserciones de tipo con instrucciones if-else, especialmente cuando necesitas manejar varios tipos diferentes en un mismo lugar.

Desafío

Fácil

En este desafío, practicarás el uso de aserciones de tipo para manejar varios tipos de datos en un sistema de notificaciones. Crearás una función que procese diferentes tipos de notificaciones y les dé el formato adecuado según su tipo concreto.

Recibirás dos entradas:

Una cadena que representa el tipo de notificación (por ejemplo, "email", "sms", "push" o "alert")
Una cadena que representa el contenido o valor de la notificación

Tu tarea es:

Crear una función llamada processNotification que reciba un parámetro interface{}
Según la entrada del tipo de notificación, convertir el contenido al tipo de Go adecuado y almacenarlo en una variable interface{}:
- Para "email": usar el contenido como una cadena
- Para "sms": convertir el contenido a un entero (que representa el recuento de caracteres)
- Para "push": convertir el contenido a un booleano (true para "enabled", false para cualquier otra cosa)
- Para "alert": convertir el contenido a un float64 (que representa el nivel de prioridad)
Llamar a la función processNotification con el valor convertido
Dentro de processNotification, usar una aserción de tipo para manejar cada tipo e imprimir el mensaje adecuado:
- Para string: "Email notification: [value]"
- Para int: "SMS notification with [value] characters"
- Para bool: "Push notifications: [value]"
- Para float64: "Alert with priority: [value]"
- Para cualquier otro tipo: "Unknown notification type"

Usa el paquete strconv para las conversiones de cadenas. Para la conversión booleana, solo "enabled" debe dar como resultado true. Este desafío demuestra cómo las aserciones de tipo proporcionan una forma clara de manejar varios tipos en una única estructura de control, dándote automáticamente el valor con el tipo correcto en cada caso.

Imprime el float64 en su forma más corta, como lo hacen fmt.Println o los verbos %v / %g: 3.5 se imprime como 3.5 y 1.0 como 1 (el verbo %f imprimiría 1.000000).

Pruébalo tú mismo

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// Leer entrada
	var notificationType string
	var content string
	fmt.Scanln(&notificationType)
	fmt.Scanln(&content)
	
	// TODO: Escribe tu código debajo
	// 1. Create processNotification function that takes interface{} parameter
	// 2. Convert content to appropriate type based on notificationType
	// 3. Call processNotification with the converted value
	// 4. Use type switch inside processNotification to handle different types
	
}

Ponte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Todas las lecciones de Lógica y Flujo

Practica por tu cuenta: Compilador de Go online