Condicionais Switch em

Sobre Condicionais Switch

Uma instrução switch avalia uma expressão e executa o primeiro case que corresponde ao valor dessa expressão. É muitas vezes uma alternativa mais limpa às longas cadeias de if ... else if.

Utilização básica

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
}

É possível agrupar vários valores num único case com uma vírgula. O case corresponde se a expressão for igual a um deles:

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 sem expressão

A expressão a seguir a switch também pode ser omitida por completo. Cada case contém então uma expressão Boolean, e é executado o primeiro que for avaliado 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
}

Instrução de inicialização

Tal como o if, um switch pode incluir uma instrução de inicialização curta antes da expressão. As variáveis aí declaradas têm âmbito limitado ao bloco do 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

O fallthrough faz com que o corpo do case seguinte seja executado, independentemente de a sua expressão corresponder ou não. Tem de ser a última instrução do corpo do case e tem de existir um case seguinte.

O fallthrough é pouco comum em Go idiomático, porque torna os case adjacentes dependentes uns dos outros. Por consequência, é mais difícil raciocinar sobre os case isoladamente, o que torna o switch mais difícil de ler. Quando os case devem ter o mesmo comportamento, agrupá-los com uma vírgula é mais claro. Quando a lógica é partilhada entre case por outros motivos, considera extrair essa lógica partilhada para uma função 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 saberes mais, consulta Go by Example: Switch ou a especificação da linguagem Go.