Introducción
En la práctica anterior, aprendimos a utilizar las sentencias de bifurcación if-else. En esta sesión, exploraremos las sentencias switch-case. A diferencia de if-else, las sentencias switch resultan mucho más adecuadas y legibles cuando nos enfrentamos a escenarios con múltiples condiciones.
Puntos de conocimiento:
- Sentencias switch-case
- La palabra clave default
- La palabra clave fallthrough
Sintaxis básica
La sintaxis de la sentencia de bifurcación switch es conceptualmente similar a la de if, ya que ambas se basan en evaluaciones condicionales. La estructura básica es la siguiente:
switch condition {
case val1:
// bloque de código
case val2:
// bloque de código
...
default:
// bloque de código
}
La condición puede ser cualquier tipo de expresión. Cuando el resultado de la condición coincide con el valor de una sentencia case específica, se ejecuta el bloque de código correspondiente y el programa sale inmediatamente de la estructura switch.
Es fundamental que los valores definidos en los case sean del mismo tipo que el resultado de la expresión de condición.
El programa evalúa los casos de arriba hacia abajo y ejecuta el primero que coincida. Una vez finalizada dicha ejecución, se abandona el bloque switch.
La sentencia default funciona de forma similar al else. Si ninguna de las opciones anteriores coincide con la condición, se ejecutará el bloque de código dentro de default.
Veamos un ejemplo práctico con un pronóstico del tiempo. Crea un nuevo archivo llamado switch.go y escribe el siguiente código:
cd ~/project
touch switch.go
package main
import (
"fmt"
)
func main() {
// Clima de hoy
weather := "rainy"
switch weather {
case "snow":
fmt.Println("Remember to wear a scarf today.🧣")
case "rainy":
fmt.Println("Remember to bring an umbrella today.🌂")
default:
fmt.Println("Today is sunny.☀")
}
}
Ejecuta el código:
go run switch.go
La salida será la siguiente:
Remember to bring an umbrella today.🌂
Este programa de clima genera diferentes resultados según la condición meteorológica. Primero, definimos el clima de hoy como "rainy" (lluvioso). En la estructura switch-case, establecemos tres condiciones: si nieva, te recordamos usar bufanda; si llueve, te recordamos llevar paraguas; de lo contrario, consideramos que es un día soleado.
Múltiples valores en una bifurcación
Una sola sentencia case puede contener múltiples valores separados por comas, como se muestra a continuación:
switch condition {
case val1, val2:
// bloque de código
...
}
Hemos actualizado nuestro programa de clima para reflejar esto:
package main
import (
"fmt"
)
func main() {
// Clima de hoy
weather := "snow"
switch weather {
case "snow", "stormy":
fmt.Println("Remember to wear a scarf today.🧣")
case "haze", "sandstorm":
fmt.Println("Remember to wear a mask today.😷")
case "rainy":
fmt.Println("Remember to bring an umbrella today.🌂")
default:
fmt.Println("Today is sunny.☀")
}
}
go run switch.go
Tras ejecutar el código, obtendrás:
Remember to wear a scarf today.🧣
En esta versión, añadimos más condiciones. Por ejemplo, ahora sugerimos usar mascarilla si hay neblina o tormenta de arena.
Sentencias switch sin variable condicional
La variable condicional en una sentencia switch es opcional. Cuando se omite, el switch se comporta de manera muy similar a una cadena de sentencias if-else.
A continuación, reescribimos un programa para mostrar el día de la semana actual utilizando un switch sin variable condicional:
package main
import (
"fmt"
"time"
)
func main() {
today := time.Now().Weekday()
switch {
case today == time.Monday:
fmt.Println("Today is Monday.")
case today == time.Tuesday:
fmt.Println("Today is Tuesday.")
case today == time.Wednesday:
fmt.Println("Today is Wednesday.")
case today == time.Thursday:
fmt.Println("Today is Thursday.")
case today == time.Friday:
fmt.Println("Today is Friday.")
case today == time.Saturday:
fmt.Println("Today is Saturday.")
default:
fmt.Println("Today is Sunday.")
}
}
go run switch.go
Al ejecutar el código, la salida será (dependiendo del día actual):
Today is Monday.
En este programa, hemos eliminado la variable de la cabecera del switch. Al ejecutarse, Go evaluará si las expresiones booleanas de cada case son verdaderas. Cuando se cumple una condición, se ejecuta su bloque y se sale del switch.
La sentencia fallthrough
Como mencionamos anteriormente, Go sale automáticamente del bloque switch tras ejecutar un caso exitoso.
Si necesitas que el programa continúe ejecutando el siguiente bloque de código inmediatamente después de un case (sin evaluar la condición del siguiente), puedes usar la sentencia fallthrough.
Estas son las reglas para usar fallthrough:
- Por defecto, si el
switchcoincide con elcase 10, no ejecutará los casos siguientes.fallthroughfuerza la ejecución del siguiente bloque. fallthroughsolo afecta al siguientecaseinmediato y no realiza ninguna validación de condición sobre él.- No se puede utilizar
fallthroughen el último bloque delswitch.
Veamos un ejemplo concreto:
package main
import (
"fmt"
)
func main() {
n := 10
switch n {
case 10:
fmt.Println(10)
fallthrough
case 3:
fmt.Println(3)
}
}
go run switch.go
La salida será:
10
3
Aunque n no es igual a 3, el programa imprime 3 porque la sentencia fallthrough en el caso anterior obligó al flujo a entrar en el siguiente bloque.
Sentencia de inicialización en switch
En Go, al igual que en las sentencias if, los bloques switch permiten incluir una sentencia de inicialización. Puedes declarar una variable justo antes de la condición, separándolas con un punto y coma.
Desafío
Tu tarea consiste en reescribir el programa de la sección anterior moviendo la declaración de la variable directamente dentro de la sentencia switch.
Crea un nuevo archivo llamado switch2.go en el directorio ~/project y modifica el código anterior para integrar la inicialización.
cd ~/project
touch switch2.go
El código base es el siguiente:
package main
import (
"fmt"
)
func main() {
n := 10
switch n {
case 10:
fmt.Println(1)
fallthrough
case 3:
fmt.Println(3)
}
}
Requisitos:
- El archivo
switch2.godebe estar ubicado en el directorio~/project.
Pista: Puedes tomar como referencia la sección de inicialización del laboratorio de if-else para realizar la modificación.
Resumen
En este laboratorio, hemos explorado la sentencia de bifurcación switch. Los puntos clave que debes recordar son:
- Cuando un
casecoincide y se ejecuta, el programa sale automáticamente del bloqueswitch. - Puedes utilizar
fallthroughpara forzar la ejecución del bloque de código del siguientecase. switchadmite una sentencia de inicialización, separada de la expresión condicional por un punto y coma.
