Condicionales switch en

Acerca de Condicionales switch

Una instrucción switch evalúa una expresión y ejecuta el primer case que coincide con su valor. A menudo es una alternativa más limpia a 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 único case separándolos 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

También se puede omitir por completo la expresión que sigue a switch. En ese caso, cada case contiene una expresión Boolean y se ejecuta el primero que se evalúe como 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
}

Instrucción de inicialización

Al igual que if, un switch puede incluir una instrucción corta de inicialización antes de la expresión. Las variables que se declaran ahí quedan dentro del scope del 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 o no. Tiene que ser la última instrucción del cuerpo del case y tiene que haber un case siguiente que ejecutar.

fallthrough no es habitual en el Go idiomático, porque hace que los case adyacentes dependan unos de otros. Como consecuencia, es más difícil razonar sobre cada case por separado, lo que hace que el switch sea más difícil de leer. Cuando varios case deben tener el mismo comportamiento, agruparlos con una coma es más claro. Cuando la lógica se comparte entre varios case por otros motivos, 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 saber más, consulta Go by Example: Switch o la especificación del lenguaje Go.