0Pricing
Go Academy · Lección

Sentencias switch en Go

switch con expresión y sin ella, y fallthrough

Sentencias switch en Go es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

Fundamentos de switch

El switch de Go es más potente que el de C: no hay fallthrough de forma predeterminada y los casos pueden tener varios valores:

day := "Monday"
switch day {
case "Saturday", "Sunday":
    fmt.Println("Weekend")
default:
    fmt.Println("Weekday")
}

Sin fallthrough implícito

En Go, el cuerpo de cada case termina automáticamente, a diferencia de C, donde debe escribir break explícitamente:

  • Código más claro y menos errores
  • Use fallthrough explícitamente cuando necesite el comportamiento de C; es poco frecuente

switch con sentencia de inicialización

Al igual que if, switch acepta una sentencia de inicialización opcional:

switch os := runtime.GOOS; os {
case "linux":
    fmt.Println("Linux")
case "darwin":
    fmt.Println("macOS")
default:
    fmt.Printf("Other: %s\n", os)
}

switch sin expresión (alternativa a una cadena de if-else)

Un switch sin expresión no tiene ninguna expresión después de la palabra clave; cada case evalúa un booleano:

score := 75
switch {
case score >= 90:
    fmt.Println("A")
case score >= 80:
    fmt.Println("B")
case score >= 70:
    fmt.Println("C")
default:
    fmt.Println("F")
}

switch de tipos

Un switch de tipos inspecciona el tipo dinámico de un valor de interfaz:

func describe(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("int: %d\n", v)
    case string:
        fmt.Printf("string: %s\n", v)
    default:
        fmt.Printf("unknown: %T\n", v)
    }
}

fallthrough

Use fallthrough para ejecutar explícitamente el cuerpo del caso siguiente sin importar su condición; rara vez es necesario:

n := 1
switch n {
case 1:
    fmt.Println("one")
    fallthrough
case 2:
    fmt.Println("one or two")
}

Varios valores por caso

Enumere varios valores separados por comas en un solo caso:

func isVowel(c byte) bool {
    switch c {
    case 'a', 'e', 'i', 'o', 'u':
        return true
    }
    return false
}

switch frente a if-else

Use switch cuando:

  • Compare una expresión con muchos valores
  • Tenga un switch de tipos para despachar según el tipo de una interfaz
  • Mejore la legibilidad frente a una cadena de if-else

Use if-else cuando las condiciones sean expresiones booleanas diferentes.

break en switch

Para salir antes de un switch, use break. Para salir de un bucle externo desde un switch, use un break con etiqueta:

loop:
for {
    switch input() {
    case "quit":
        break loop  // exits the for loop
    }
}

Caso predeterminado

El caso default se ejecuta cuando no coincide ningún otro caso. Prácticas recomendadas:

  • Incluya siempre default al gestionar enumeraciones para detectar valores inesperados
  • Colóquelo al final para mejorar la legibilidad
  • En los switches de tipos, use default para gestionar correctamente los tipos no compatibles

Comprobación rápida

¿Qué ocurre en Go cuando coincide un caso de switch? ¿La ejecución continúa en el caso siguiente?

Resumen: switch en Go

El switch de Go es claro y potente:

  • No hay fallthrough implícito; use fallthrough explícitamente
  • Sentencia de inicialización para limitar el ámbito de valores temporales
  • Switch sin expresión como alternativa a una cadena de if-else
  • Switch de tipos para despachar según el tipo de una interfaz
  • Varios valores por caso, separados por comas

Siguiente tema: control de bucles con break, continue y etiquetas.

Preguntas frecuentes

¿La lección «Sentencias switch en Go» es gratis?

Sí — el texto completo de «Sentencias switch en Go» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Sentencias switch en Go»?

switch con expresión y sin ella, y fallthrough Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Sentencias switch en Go»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Sentencias if y expresiones de inicialización
  2. El bucle for: todos los patrones
  3. Sentencias switch en Go
  4. break, continue y etiquetas
← Volver a Go Academy