Type Switch

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

Si bien 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 una sentencia switch de tipo resulta increíblemente útil: ofrece una forma clara de realizar distintas acciones según el tipo concreto.

Un switch de tipo utiliza esta sintaxis especial: switch v := i.(type). Fíjate en 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 caso, v tiene automáticamente el tipo correcto: no se necesita ninguna aserción de tipo adicional. Esto hace que los switches de tipo sean mucho más claros 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 conmutaciones de tipo para manejar varios tipos de datos en un sistema de notificaciones. Crearás una función que procesa distintos tipos de notificaciones y les da 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 en un entero (que representa el recuento de caracteres)
- Para "push": convertir el contenido en un booleano (true para "enabled", false para cualquier otra cosa)
- Para "alert": convertir el contenido en un float64 (que representa el nivel de prioridad)
Llamar a la función processNotification con el valor convertido
Dentro de processNotification, usar una conmutació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 a booleano, solo "enabled" debe dar como resultado true. Este desafío demuestra cómo las conmutaciones de tipo ofrecen una forma sencilla de manejar varios tipos en una sola estructura de control y te proporcionan automáticamente un 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() {
	// Lee la entrada
	var notificationType string
	var content string
	fmt.Scanln(&notificationType)
	fmt.Scanln(&content)
	
	// TODO: Escribe tu código a continuación
	// 1. Crea la función processNotification que reciba un parámetro de tipo interface{}
	// 2. Convierte content al tipo adecuado según notificationType
	// 3. Llama a processNotification con el valor convertido
	// 4. Usa un type switch dentro de processNotification para manejar distintos tipos
	
}

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