Estruturas condicionais e de repetição na Go \| TreinaWeb Promoção no ar Matricule-se agora e garanta **54% de desconto** Termina em Tempo restante da oferta: 03 Horas 20 Min 28 Seg Tempo restante da oferta: 03 20 28 [Assinar →](https://www.treinaweb.com.br/checkout/pagamento/plano/anual?cupom=TW-SCLIENTE26) [ ](https://www.treinaweb.com.br) Explorar [ Quanto custa? ](#assinatura) [ FAQ ](https://www.treinaweb.com.br#faq) [Matricule-se](#assinatura) [ Entrar ](https://www.treinaweb.com.br/login) [ Início ](https://www.treinaweb.com.br) [ Artigos ](https://www.treinaweb.com.br/blog) Estruturas condicionais e de repetição na Go [ Desenvolvimento Back-end ](https://www.treinaweb.com.br/blog/categoria/desenvolvimento-back-end) [ Go ](https://www.treinaweb.com.br/blog/categoria/go) # Estruturas condicionais e de repetição na Go Veremos nesse artigo sobre quais são e como podemos utilizar as estruturas condicionais e as estruturas de repetição na linguagem Go [ Cleyson Lima ](https://www.treinaweb.com.br/blog/autor/cleyson-lima) 4 anos atrás ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2022/10/o-que-e-e-como-comecar-com-golang.jpg) No artigo anterior vimos sobre [variáveis e constantes na Golang](https://www.treinaweb.com.br/blog/conhecendo-variaveis-e-constantes-na-golang), agora nós vamos aprender quais são e como utilizar as estruturas condicionais e de repetição disponíveis na linguagem Go. As estruturas condicionais estão diretamente ligadas ao processo de tomada de decisão dentro de um algoritmo, são elas que nos permitem alterar o fluxo de execução do código dependendo dos valores com os quais estamos trabalhando. Já as estruturas de repetição, assim como o nome já diz, nos permitem repetir certos trechos de códigos um número determinado ou indeterminado de vezes, dependendo sempre de qual a condição de parada para tal estrutura. Tanto as estruturas de repetição quanto as estruturas de condição irão trabalhar na sua maioria das vezes com valores booleanos, ou seja, `true` (verdadeiro) e `false` (falso). Caso você ainda não esteja familiarizado com os conceitos de estruturas condicionais e de repetição na lógica de programação, recomendo a leitura do artigo [Estruturas condicionais e de repetição](https://www.treinaweb.com.br/blog/estruturas-condicionais-e-de-repeticao/), que temos aqui no [blog da TreinaWeb](https://www.treinaweb.com.br/blog). ## Estruturas condicionais As estruturas condicionais possibilitam ao programa tomar decisões e alterar o seu fluxo de execução. Isso possibilita ao desenvolvedor o poder de controlar quais são as tarefas e trechos de códigos executados de acordo com diferentes situações. As estruturas condicionais geralmente analisam expressões booleanas e, caso estas expressões sejam verdadeiras, um trecho do código é executado. No caso contrário, outro trecho do código é executado. ### Estrutura if/else O [if/else](https://go-tour-br.appspot.com/flowcontrol/5) é uma estrutura de condição em que uma expressão booleana é analisada. Quando a condição que estiver dentro do `if` for verdadeira, ela é executada. Já o `else` é utilizado para definir o que é executado quando a condição analisada pelo `if` for falsa. Caso o `if` seja verdadeiro e, consequentemente, executado, o `else` não é executado. O `if` pode ser utilizado em conjunto com o `else` ou até mesmo sozinho, caso necessário. Abaixo, temos um exemplo onde o `if` é utilizado em conjunto com o `else`. ```go package main import "fmt" func main() { idade := 18 if idade >= 18 { // Se a váriavel idade for maior ou igual à 18 esse trecho de código será executado fmt.Println("Você é maior de idade!") } else { // Se a váriavel idade não for maior ou igual à 18 esse trecho de código será executado fmt.Println("Você é menor de idade!") } } ``` Também podemos utilizar somente o `if`, não definindo um fluxo alternativo. ```go package main import "fmt" func main() { idade := 18 if idade >= 18 { // Se a váriavel idade for maior ou igual à 18 esse trecho de código será executado fmt.Println("Você é maior de idade!") } // Se a váriavel idade não for maior ou igual à 18, nenhuma frase será exibida } ``` Ainda é possível encadear múltiplas estruturas `if/else` caso necessário. ```go package main import "fmt" func main() { idade := 18 if idade >= 18 { // Se a váriavel idade for maior ou igual à 18 esse trecho de código será executado fmt.Println("Você é maior de idade!") } else if idade >= 16 { // Se a váriavel idade não for maior ou igual à 18 mas for maior ou igual a 16 esse trecho de código será executado fmt.Println("Você não é maior de idade, mas já pode votar!") } else { // Se a váriavel idade não for maior ou igual à 18 esse trecho de código será executado fmt.Println("Você é menor de idade!") } } ``` ### Estrutura switch/case A estrutura condicional [switch/case](https://go-tour-br.appspot.com/flowcontrol/9) vem como alternativa, em momentos, em que temos que utilizar múltiplos `if's` no código. Múltiplos `if/else` encadeados tendem a tornar o código muito extenso, pouco legível e com baixo índice de manutenção. O `switch/case` testa o valor contido em uma variável, realizando uma comparação com cada uma das opções. Cada uma dessas possíveis opções é delimitada pela instrução `case`. Podemos ter quantos casos de análise forem necessários e, quando um dos valores corresponder ao da variável, o código do `case` correspondente será executado. Caso a variável não corresponda a nenhum dos casos testados, o último bloco será executado, chamado de `default` (padrão). ```go package main import "fmt" func main() { mes := 1 switch mes { case 1: fmt.Println("O mês é Janeiro!") case 2: fmt.Println("O mês é Fevereiro") case 3: fmt.Println("O mês é Março") case 4: fmt.Println("O mês é Abril") case 5: fmt.Println("O mês é Maio") case 6: fmt.Println("O mês é Junho") case 7: fmt.Println("O mês é Julho") case 8: fmt.Println("O mês é Agosto") case 9: fmt.Println("O mês é Setembro") case 10: fmt.Println("O mês é Outubro") case 11: fmt.Println("O mês é Novembro") case 12: fmt.Println("O mês é Dezembro") default: fmt.Println("Mês inválido") } } ``` Na maioria das linguagens que possuem a estrutura `switch/case`, é necessário colocar a instrução `break` ao final de cada cláusula `case`, mas na linguagem Go, isso não é necessário. ## Estruturas de repetição Estruturas de repetição, também conhecidas como loops (laços), são utilizadas para executar repetidamente uma instrução ou bloco de instrução enquanto determinada condição estiver sendo satisfeita. Na linguagem Go temos apenas uma estrutura de repetição, sendo a estrutura `for`, porém ela pode ser executada de maneiras diferentes, assim, tendo comportamentos diferentes. ### Estrutura for com condição simples O [for com condição simples](https://go-tour-br.appspot.com/flowcontrol/3) é uma estrutura de repetição que irá repetir o bloco de código enquanto uma determinada condição for verdadeira, geralmente utilizamos essa estrutura quando não sabemos quantas vezes o trecho de código em questão deve ser repetido. Essa estrutura possui a seguinte sintaxe: ```go for { // Trecho de código a ser repetido } ``` Abaixo, temos um exemplo do `for` com condição simples. Neste exemplo, é pedido ao usuário que tente adivinhar o número. Enquanto o usuário não acerta o número, é pedido para que o usuário digite o valor que ele acha que é o correto. Perceba que nós temos um trecho de código que é sempre repetido, o pedido do número para o usuário. Mas, não sabemos exatamente quando o usuário vai acertar este número, ou seja, não sabemos exatamente quantas vezes o trecho de código será repetido. Nessa situação, o `for` com condição simples é a estrutura de repetição mais adequada. ```go package main import "fmt" func main() { numero := -1 for numero != 10 { fmt.Print("Digite um número: ") fmt.Scanln(&numero) if numero < 10 { fmt.Println("Você errou, tente um número maior") } else if numero > 10 { fmt.Println("Você errou, tente um número menor") } else { fmt.Println("Você acertou") } } } ``` ### Estrutura for clássica O [for clássico](https://go-tour-br.appspot.com/flowcontrol/1) é uma estrutura de repetição que trabalha com uma variável de controle e que repete o seu bloco de código até que uma determinada condição que envolve essa variável de controle seja falsa, geralmente utilizamos essa estrutura `for` quando sabemos a quantidade de vezes que o laço precisará ser executado. O `for` clássico possui a seguinte sintaxe: ```go for ; ; { // Trecho de código a ser repetido } ``` Quando utilizamos o `for` clássico, precisamos de uma variável para auxiliar a controlar a quantidade de repetições a serem executadas. Essa variável é chamada de variável de controle, declarada no primeiro argumento do `for`. O segundo argumento do `for` clássico é utilizado para definir até quando o `for` será executado. Geralmente, trata-se de uma condição booleana em cima da variável de controle. O terceiro argumento indica o quanto a variável de controle será modificada no final de cada execução dentro do `for` clássico. Veja o exemplo abaixo: ```go package main import "fmt" func main() { for i := 1; i