Sentencia switch en Go con ejemplos reales

Contenido del curso

Introducción y Configuración

Fundamentos de Go

Estructuras de Datos y Funciones

Manejo de Errores y Concurrencia

Buenas Prácticas en Go

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:007:16

Sentencia switch en Go con ejemplos reales

Curso de Go

Clase 8 de 28

Clase 8 / 28

Recursos

La sentencia switch en Go te permite ejecutar bloques de código según el valor de una variable, sin recurrir a cadenas largas de if/else. Si estás aprendiendo Go y buscas una forma más limpia de manejar decisiones, aquí verás cómo funciona con ejemplos prácticos usando enteros, días de la semana y horas del sistema.

¿Qué es la sentencia switch en Go y cuándo usarla?

A diferencia del for, el switch no es un ciclo: es una estructura de selección. Evalúa una variable y ejecuta el bloque del case que coincida con su valor. Es ideal cuando tienes varias rutas posibles para una misma variable y quieres mantener tu código legible.

¿Qué hace switch en Go? Compara el valor de una expresión contra varios case. Cuando encuentra coincidencia, ejecuta ese bloque. Si ninguno coincide, corre el bloque default.

¿Cómo se escribe un switch básico con una variable entera?

Dentro de la carpeta switch creas un archivo main.go con la estructura básica del paquete main. Declaras una variable i := 2, imprimes su valor inicial con fmt.Println("Escribe", i) y luego escribes la sentencia.

go switch i { case 1: fmt.Println(1) case 2: fmt.Println(2) case 3: fmt.Println(3) }

Al ejecutar go run main.go, si i vale 2, cae en el case 2. Si cambias la variable a 3, cae en el case 3. Un detalle útil: la coma dentro de Println actúa como separador y permite concatenar una cadena con un entero sin usar el signo de más.

¿Cómo usar switch con el paquete time para días de la semana?

Go trae el paquete time, que expone constantes como time.Saturday y time.Sunday. Estas son palabras reservadas del lenguaje, así que debes usarlas en inglés dentro del case.

go switch time.Now().Weekday() { case time.Saturday, time.Sunday: fmt.Println("A descansar") default: fmt.Println("Toca grabar más cursos en Platzi") }

Aquí time.Now().Weekday() devuelve el día actual del sistema. Si cae en sábado o domingo, imprime A descansar. Cualquier otro día activa el bloque default, que es la salida por defecto cuando ninguna condición se cumple. Si grabas un jueves, por ejemplo, te toca seguir trabajando.

¿Para qué sirve default en switch? Es el bloque que se ejecuta cuando ningún case coincide con el valor evaluado. Funciona como red de seguridad para cubrir todos los escenarios.

¿Puedo declarar la variable fuera del switch?

Sí, y a veces es más cómodo. En lugar de meter time.Now() dentro del switch, puedes guardarlo en una variable externa llamada tiempo y luego compararla. El comportamiento es idéntico, solo cambia la legibilidad.

go tiempo := time.Now() switch { case tiempo.Hour() < 12: fmt.Println("Debes decir buenos días") case tiempo.Hour() >= 12: fmt.Println("Buenas tardes") }

Este patrón se llama switch sin expresión: cada case contiene una condición booleana completa. Si la hora del equipo marca 12:01, imprime Buenas tardes. Si fueran las 9:00, imprimiría Buenos días.

¿Qué diferencia hay entre switch con expresión y switch sin expresión?

Las dos formas son válidas y se eligen según el caso de uso. La primera es más directa cuando comparas valores exactos; la segunda da flexibilidad para evaluar rangos o condiciones complejas.

Switch con expresión: evalúas una variable contra valores específicos, como en switch i con case 1, 2, 3.
Switch sin expresión: cada case es una condición booleana, útil para comparar rangos como horas o tamaños.
Case con múltiples valores: puedes agrupar valores separados por coma, como case time.Saturday, time.Sunday.

¿Cuándo uso switch en lugar de if/else? Cuando tienes tres o más caminos posibles para una misma variable. El switch mejora la lectura y reduce la repetición de comparaciones.

Reto: traducir los días de la semana al español

El método Weekday() devuelve los días en inglés porque son constantes del paquete time. El reto es usar un switch que reciba now.Weekday() y produzca como salida el nombre del día en español, como lunes, martes o miércoles. Es un buen ejercicio para combinar lo que viste sobre case múltiples y conversión de tipos.

Cuéntame en los comentarios cómo te fue con el ejercicio y qué estructura usaste para resolverlo.

Juan Diego Mejia Maestre

Hace 9 meses

Aquí tienes el resumen de la sentencia switch en Go, optimizado para tus notas de Notion, con datos técnicos adicionales para que seas un experto en el lenguaje.

🔀 Sentencia Switch en Go: Selección Inteligente

A diferencia de otros lenguajes, en Go el switch es más potente y flexible. No requiere de la palabra break al final de cada caso, ya que Go detiene la ejecución automáticamente al encontrar una coincidencia.

📋 Estructura Estándar

Se usa para comparar una variable contra múltiples valores fijos.

var i int = 2
switch i {
case 1:
    fmt.Println("Uno")
case 2:
    fmt.Println("Dos") // Se ejecuta este y sale
case 3:
    fmt.Println("Tres")
default:
    fmt.Println("No reconocido")
}

🕒 Switch con el Paquete time

Go permite evaluar expresiones complejas o funciones directamente en la cabecera del switch.

import "time"

switch hoy := time.Now().Weekday(); hoy {
case time.Saturday, time.Sunday:
    fmt.Println("Es fin de semana 🥳")
default:
    fmt.Println("Día de trabajar 💻")
}

🛠️ Variaciones Avanzadas

1. Switch sin Expresión (Estilo If-Else)

Si no pones una variable después de la palabra switch, funciona como una cadena de if-else limpia.

t := time.Now().Hour()
switch {
case t < 12:
    fmt.Println("Buenos días")
case t < 19:
    fmt.Println("Buenas tardes")
default:
    fmt.Println("Buenas noches")
}

2. La palabra clave fallthrough

En Go, el código no "cae" al siguiente caso por defecto. Si quieres que se ejecute el siguiente bloque aunque la condición no se cumpla, debes usar fallthrough.

switch numero := 10; {
case numero > 5:
    fmt.Println("Es mayor a 5")
    fallthrough
case numero > 100:
    fmt.Println("Esto también se imprimirá por el fallthrough")
}

3. Switch de Tipo (Type Switch)

Una característica única de Go es comparar el tipo de una interfaz, no solo su valor.

var x interface{} = "Hola"
switch x.(type) {
case int:
    fmt.Println("Es un entero")
case string:
    fmt.Println("Es un string")
}

⚠️ Reglas de Oro en Go

Sin break manual: Go lo hace por ti. Si vienes de C o Java, ¡olvida el break!
Casos múltiples: Puedes agrupar valores con comas: case 1, 2, 3:.
Orden de evaluación: Los casos se evalúan de arriba hacia abajo hasta encontrar el primero que sea verdadero.

Introducción y Configuración

Características y ventajas del lenguaje de programación Go

Instala Go en WSL con un comando

Paquetes en Go sin npm ni pip

Fundamentos de Go

Formas de declarar variables en Go

Conversión de tipos en Go

if else y operador módulo en Go

Cuatro formas de usar for en Go

Estructuras de Datos y Funciones

Sentencia switch en Go con ejemplos reales

Arreglos en Go: fijos e inferidos

Creación y uso de slices dinámicos en Go

Mapas en Go: creación, acceso y manipulación de datos clave-valor

Cómo crear y usar funciones personalizadas en Go

Retorno de múltiples valores en Go

Funciones variadic en Go con tres puntos

Funciones recursivas en Go con Fibonacci

Punteros en Go para optimizar rendimiento del sistema

Runas en Go: bytes vs caracteres reales

Declaración y uso de estructuras de datos en Go

Implementación de enumeradores en Go para controlar estados

Manejo de Errores y Concurrencia

Errores personalizados en Go

Goroutines y channels en Go

Select para ordenar goroutines en Go

Timeouts en goroutines con time.After

Workers en Go con goroutines y channels

Buenas Prácticas en Go

JSON con Marshal y Unmarshal en Go

Conversión de texto plano a hash con SHA256 en Go

Variables de ambiente en Go con paquetes externos

Cierre de curso de Go: consejos para consolidar el aprendizaje

Sentencia switch en Go con ejemplos reales