Condicionais switch em

Sobre Condicionais switch

Uma instrução switch avalia uma expressão e executa o primeiro case cujo valor corresponde. Muitas vezes, ela é uma alternativa mais limpa a longas cadeias 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
}

É possível agrupar vários valores em um único case com uma vírgula. O case corresponde se a expressão for igual a qualquer 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 depois de switch também pode ser omitida por completo. Cada case então contém uma expressão Boolean, e o primeiro que resultar em true é executado.

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

Assim como o if, um switch pode incluir uma instrução curta de inicialização antes da expressão. As variáveis declaradas ali têm escopo restrito ao bloco 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 próximo case seja executado, independentemente de sua expressão corresponder ou não. Ele precisa ser a última instrução no corpo do case, e é preciso que exista um próximo case para executar.

O fallthrough é incomum em Go idiomático porque torna cases adjacentes dependentes uns dos outros. Por isso, fica mais difícil raciocinar sobre os cases isoladamente, o que deixa o switch mais difícil de ler. Quando cases devem ter o mesmo comportamento, agrupá-los com uma vírgula é mais claro. Quando a lógica é compartilhada entre cases por outros motivos, considere extrair essa lógica compartilhada 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 saber mais, consulte Go by Example: Switch ou a especificação da linguagem Go.