Outra forma de tomar decisões em programas escritos em Go, é a utilização do comando switch que nos permite testar vários casos e executar um bloco de código quando uma condição para um caso é verdadeira. Nesta parte do tutorial vamos ver o comando switch.

Os comandos de escolha bem como o seus funcionamentos já foram discutidos em Portugol: Comando de Escolha sendo a leitura recomendada.

Para fazermos escolhas da linguagem de programação Go, utilizamos o comando switch que possui sua sintaxe apresentada abaixo.

Fig. 1: Fluxograma Comando switch

Sintaxe

switch valor ou expressao {
    case caso1:
        //código
            //break opcional
    case caso2: 
        //código
            //break opcional
    case casoN:
    default: //opcional
}

Onde

valor: argumento que desejamos verificar se existe algum caso associado. 
Podem conter valores numérico, texto. 
caso1..casoN: casos comparados com valor. Se o resultado for verdadeiro, o trecho de código 
dentro do caso é executado.

Diferente de outras linguagens como C/C++, Java e C# e outros, em Go o comando break é opcional para interromper a execução de um case. Para ver como funciona o comando break visite Comando Break.

O caso default é opcional. Com esse caso, podemos executar algum trecho de código caso o valor não seja igual a algum dos valores da cláusula case.

Exemplo 1: valor inteiro

package main
import "fmt"

func main() {
	valor := 3
	switch valor {
	    case 1:
		    fmt.Println("1")
	    case 2:
		    fmt.Println("2")
	    case 3:
		    fmt.Println("3")
	    default:
		    fmt.Println("não encontrado")
	}
}

Saída

3

Como mencionado na sintaxe acima, a linguagem Go, permite o uso do comando switch com strings:

Exemplo 2

package main
import "fmt"

func main() {
	valor := "tres"
	switch valor {
	case "um":
		fmt.Println("1")
	case "dois":
		fmt.Println("2")
	case "tres":
		fmt.Println("3")
	default:
		fmt.Println("não encontrado")
	}
}

Saída

3

Para a execução de um mesmo trecho de código para mais de uma case, basta adicionar as cláusulas case em sequência ou um abaixo do outro separados por (:).

Exemplo 3

package main
import "fmt"

func main() {
	valor := "tres"
	switch valor {
	    case "um":
	    case "dois":
		    fmt.Println("2")
	    case "tres":
		    fmt.Println("3")
	    default:
		    fmt.Println("não encontrado")
	}
}

Saída

2

Podemos utilizar a declaração a declaração de constantes em bloco com o bloco var como valores para comparação nos cases do comando switch.

Exemplo 4

package main

import "fmt"

type Status int

const (
	Opcao0 = iota //0
	Opcao1        //1
	Opcao2        //2
)

func main() {

	valor := Opcao2

	switch valor {
	case Opcao1:
		fmt.Println(valor)
	case Opcao2:
		fmt.Println(valor)
	case Opcao3:
		fmt.Println(valor)
	default:
		fmt.Println("inválido")
	
    }
}

Saída

2

Assim como no comando if, uma função pode ser utilizada como argumento de comparação do comando de escolha switch. Isso pode ser visto no exemplo a seguir:

Exemplo 5

package main

import "fmt"

func funcao(val int) int {
    
    if val == 0 {
        return 0
    }
    
    if val == 1 {
        return 1
    }
        
    return -1
}

func main(){
    
    switch funcao(1) {
        case 0 : fmt.Println(0)
        case 1 : fmt.Println(0)
        default: fmt.Println(-1)
    }
}

Saída

1

Expressões mais complexas podem ser usadas como argumento para o comando switch. Essas expressões devem retornar um valor suportado pelo comando.

Exemplo 6

package main

import "fmt"

func main(){
    
    valor := 0xff
    switch ((valor>>4)&2) {
        case 0 : fmt.Println(0)
        case 1 : fmt.Println(1)
        default: fmt.Println(-1)
    }
}

Saída

-1

O switch nos permite utilizar expressões mais complexas em seus cases. Assim, por exemplo, podemos verificar se um valor está contido em um intervalo de valor fazendo uso dos operadores relacionais (<), (>), (<=) e (>=):

Exemplo 6

package main

import "fmt"

func main(){
    
    val := 5
    
    switch {
     case val > 0 && val < 5: fmt.Println(val*2);
     case val == 5 : fmt.Println(val*3);
     default: fmt.Println(val*3);
    }
}

Saída

15

1. 30/10/2025 - revisão 4 - Adição: função como argumento, intervalo e expressão
2. 08/09/2025 - revisão 3 - Ajustes: pontuais, target de links, objetivos e sintaxes; Adição: switch com constantes
3. 16/09/2024 - revisão 2 - Correção em link Portugol; ajustes gramaticais
4. 02/10/2023 - revisão 1 - Correção em referências, erros gramaticais e adição de fluxogramas
5. 21/08/2023 - versão inicial