Condicionales switch en

Acerca de Condicionales switch

Una sentencia switch evalúa una expresión y ejecuta el primer case que coincida con su valor. A menudo es una alternativa más limpia que las largas cadenas de if ... else if.

Uso básico

operatingSystem := "windows"

switch operatingSystem {
case "windows":
    // do something if the operating system is windows
case "linux":
    // do something if the operating system is linux
case "macos":
    // do something if the operating system is macos
default:
    // do something if the operating system is none of the above
}

Se pueden agrupar varios valores en un solo case con una coma. El case coincide si la expresión es igual a cualquiera de ellos:

switch operatingSystem {
case "windows", "linux":
    // do something if the operating system is windows or linux
case "macos":
    // do something if the operating system is macos
default:
    // do something if the operating system is none of the above
}

switch sin expresión

La expresión después de switch también se puede omitir por completo. En ese caso, cada case contiene una expresión booleana y se ejecuta la primera que evalúe a true.

age := 21

switch {
case age > 20 && age < 30:
    // do something if age is between 20 and 30
case age == 10:
    // do something if age is equal to 10
default:
    // do something else for every other case
}

Sentencia de inicialización

Igual que if, un switch puede incluir una sentencia corta de inicialización antes de la expresión. Las variables declaradas allí tienen su ámbito en el bloque del switch:

switch v := getValue(); {
case v < 0:
    // do something if v is less than 0
case v == 0:
    // do something if v is 0
default:
    // do something else for every other case
}
// v will not be accessible here

fallthrough

fallthrough hace que se ejecute el cuerpo del siguiente case, independientemente de si su expresión coincidiría. Debe ser la última sentencia del cuerpo del case, y debe haber un case siguiente que se ejecute.

fallthrough es poco común en el código idiomático de Go porque hace que los case adyacentes dependan entre sí. Como resultado, es más difícil razonar sobre los case de forma aislada, lo que hace que el switch sea más difícil de leer. Cuando los case deben tener el mismo comportamiento, agruparlos con una coma es más claro. Cuando la lógica se comparte entre varios case por otras razones, considera extraer esa lógica compartida a una función auxiliar.

s := "hello"

switch s {
case "hello":
    fmt.Println("hello")
    fallthrough
case "world":
    fmt.Println("world") // also runs, even though s != "world"
}
// Output:
// hello
// world

Para aprender más, consulta Go by Example: Switch o la especificación del lenguaje Go.