One place for hosting & domains

      instruções

      Como escrever instruções condicionais em Go


      Introdução

      As instruções condicionais fazem parte de todas as linguagens de programação. Com as instruções condicionais, podemos ter códigos que algumas vezes executam e em outras ocasiões não, dependendo das condições do programa naquele momento.

      Quando executamos totalmente cada instrução de um programa, não estamos pedindo que o programa avalie condições específicas. Ao usar as instruções condicionais, os programas podem determinar se certas condições estão sendo cumpridas e, então, ser informados do que fazer a seguir.

      Vejamos alguns exemplos de onde usaríamos as instruções condicionais:

      • Se o aluno tiver mais de 65% de acertos em seu teste, informar que ele tem nota de aprovação; caso contrário, informar que ele não conseguiu nota para aprovação.
      • Se ele tiver dinheiro em sua conta, calcular os juros; caso não tenha, cobrar uma taxa a título de multa.
      • Se eles comprarem 10 laranjas ou mais, calcular um desconto de 5%; caso eles comprem menos, não calcule.

      Ao avaliar as condições e atribuir o código a ser executado com base em se essas condições são cumpridas ou não, estamos escrevendo códigos condicionais.

      Este tutorial explicará a você sobre como escrever instruções condicionais na linguagem de programação em Go.

      Instruções if

      Começaremos com a instrução if, que avaliará se uma instrução é verdadeira ou falsa e executará o código apenas no caso em que a instrução for verdadeira.

      Num editor de texto simples, abra um arquivo e escreva o seguinte código:

      grade.go

      package main
      
      import "fmt"
      
      func main() {
          grade := 70
      
          if grade >= 65 {
              fmt.Println("Passing grade")
          }
      }
      

      Com esse código, temos a grade variável e estamos dando a ela o valor inteiro de 70. Em seguida, estamos usando a instrução if para avaliar se a nota variável é ou não maior ou igual (>=) a 65. Se ela atender a essa condição, estamos dizendo ao programa para imprimir a string Passing grade.

      Salve o programa como grade.go e o execute em um ambiente de programação local a partir de uma janela de terminal com o comando go run grade.go.

      Neste caso, a nota de 70 realmente atende à condição de ser maior ou igual a 65, de modo que você receberá o seguinte resultado assim que executar o programa:

      Output

      Passing grade

      Agora, vamos alterar o resultado deste programa, mudando o valor da variável grade para 60:

      grade.go

      package main
      
      import "fmt"
      
      func main() {
          grade := 60
      
          if grade >= 65 {
              fmt.Println("Passing grade")
          }
      }
      

      Ao salvarmos e executarmos este código, não iremos receber nenhum resultado porque a condição não foi cumprida e não dissemos ao programa para executar outra instrução.

      Para dar mais um exemplo, vamos calcular se um saldo de conta bancária está abaixo de 0. Vamos criar um arquivo chamado account.go e escrever o seguinte programa:

      account.go

      package main
      
      import "fmt"
      
      func main() {
          balance := -5
      
          if balance < 0 {
              fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
          }
      }
      

      Quando executarmos o programa com o go run account.go, receberemos o seguinte resultado:

      Output

      Balance is below 0, add funds now or you will be charged a penalty.

      No programa, nós inicializamos a variável balance com o valor de -5, que é menor que 0. Como o saldo cumpriu a condição da instrução if (balance < 0), assim que salvarmos e executarmos o código, receberemos o resultado da string. Novamente, se alterarmos o saldo para 0 ou um número positivo, não iremos receber nenhum resultado.

      Instruções else

      É provável que queiramos que o programa faça algo mesmo quando uma instrução if avalia algo como falso. No nosso exemplo de nota, queremos produzir o resultado de se a nota é de aprovação ou desaprovação.

      Para fazer isso, adicionaremos uma instrução else na condição da nota acima que é construída dessa forma:

      grade.go

      package main
      
      import "fmt"
      
      func main() {
          grade := 60
      
          if grade >= 65 {
              fmt.Println("Passing grade")
          } else {
              fmt.Println("Failing grade")
          }
      }
      

      Como a variável de nota tem o valor de 60, a instrução if a avalia como falsa, então o programa não irá imprimir Passing grade. A instrução else que segue diz ao programa para fazer algo, de qualquer maneira.

      Quando salvarmos e executarmos o programa, receberemos o seguinte resultado:

      Output

      Failing grade

      Se reescrevermos o programa para dar à nota um valor de 65 ou mais, em vez disso, receberemos o resultado Passing grade.

      Para adicionar instrução else ao exemplo da conta bancária, reescrevemos o código desta forma:

      account.go

      package main
      
      import "fmt"
      
      func main() {
          balance := 522
      
          if balance < 0 {
              fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
          } else {
              fmt.Println("Your balance is 0 or above.")
          }
      }
      

      Output

      Your balance is 0 or above.

      Aqui, mudamos o valor da variável balance para um número positivo, de maneira que a instrução else seja impressa. Para fazer com que a primeira instrução if seja impressa, podemos reescrever o valor para um número negativo.

      Ao combinar uma instrução if com uma instrução else, você estará construindo uma instrução condicional de duas partes que irá dizer ao computador para executar certos códigos se a condição if for cumprida.

      Instruções else if

      Até agora, apresentamos uma opção Booleana para as instruções condicionais, com cada instrução if avaliando como verdadeiro ou falso. Em muitos casos, vamos querer um programa que avalie mais de dois resultados possíveis. Para fazer isso, usaremos uma instrução Senão se, que é escrita em Go como else if. A else if, ou instrução “Senão se” é parecida com a instrução if e avaliará outra condição.

      No programa da conta bancária, podemos querer ter três saídas distintas para obter três situações diferentes:

      • O saldo está abaixo de 0
      • O saldo é igual a 0
      • O saldo está acima de 0

      A instrução else if será colocada entre a instrução if e a instrução else do seguinte modo:

      account.go

      package main
      
      import "fmt"
      
      func main() {
          balance := 522
      
          if balance < 0 {
              fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
          } else if balance == 0 {
              fmt.Println("Balance is equal to 0, add funds soon.")
          } else {
              fmt.Println("Your balance is 0 or above.")
          }
      }
      

      Agora, há três possíveis resultados que podem ocorrer assim que executarmos o programa:

      • Se a variável balance for igual a 0, receberemos o resultado da instrução else if (Balance is equal to 0, add funds soon.) (Saldo igual a 0, adicione fundos logo.).
      • Se a variável balance for definida em um número positivo, receberemos o resultado da instrução else (Your balance is 0 or above.) (Seu saldo é 0 ou mais).
      • Se a variável balance for definida em um número negativo, o resultado será a string da instrução if (Balance is below 0, add funds now or you will be charged a penalty) (Saldo abaixo de 0, adicione fundos agora ou haverá cobrança de uma multa).

      Mas e se, apesar disso, quisermos ter mais de três possibilidades? Podemos fazer isso escrevendo mais de um instrução else if no nosso código.

      No programa grade.go, vamos reescrever o código para que haja algumas notas alfabéticas que correspondam a intervalos de notas numéricas:

      • 90 ou acima equivale a uma nota A
      • 80-89 equivale a uma nota B
      • 70-79 equivale a uma nota C
      • 65-69 equivale a uma nota D
      • 64 ou abaixo equivale a uma nota F

      Para executar esse código, precisaremos de uma instrução if, três instruções else if e uma instrução else que lidará com todos os casos de desaprovação.

      Vamos reescrever o código do exemplo anterior para ter strings que imprimam cada uma das avaliações alfabéticas. Podemos manter nossa instrução else da mesma forma.

      grade.go

      package main
      
      import "fmt"
      
      func main() {
          grade := 60
      
          if grade >= 90 {
              fmt.Println("A grade")
          } else if grade >= 80 {
              fmt.Println("B grade")
          } else if grade >= 70 {
              fmt.Println("C grade")
          } else if grade >= 65 {
              fmt.Println("D grade")
          } else {
              fmt.Println("Failing grade")
          }
      }
      

      Como as instruções else if avaliarão em ordem, podemos manter nossas instruções bastante básicas. Este programa está completando os seguintes passos:

      1. Se a nota for maior que 90, o programa irá imprimir A grade, se a nota for menor que 90, o programa continuará com a próxima instrução…

      2. Se a nota for maior ou igual a 80, o programa irá imprimir B grade, se a nota for 79 ou menos, o programa continuará com a próxima instrução…

      3. Se a nota for maior ou igual a 70, o programa irá imprimir C grade, se a nota for 69 ou menos, o programa continuará com a próxima instrução…

      4. Se a nota for maior ou igual a 65, o programa irá imprimir D grade, se a nota for 64 ou menos, o programa continuará com a próxima instrução…

      5. O programa irá imprimir Failing grade porque todas as condições acima não foram cumpridas.

      Instruções if aninhadas

      Assim que estiver se sentindo confortável com as instruções if, else if e else, siga para as instruções condicionais aninhadas. Podemos usar as instruções if aninhadas para situações onde queremos verificar uma condição secundária caso a primeira condição execute como verdadeira. Para fazer isso, podemos ter uma instrução if-else dentro de outra instrução if-else. Vejamos a sintaxe de uma instrução if aninhada:

      if statement1 { // outer if statement
          fmt.Println("true")
      
          if nested_statement { // nested if statement
              fmt.Println("yes")
          } else { // nested else statement
              fmt.Println("no")
          }
      
      } else { // outer else statement
          fmt.Println("false")
      }
      

      Alguns possíveis resultados podem resultar deste código:

      • Se a instrução statement1 é avaliada como verdadeira, o programa irá avaliar se a nested_statement também é avaliada como verdadeira. Se ambos os casos forem verdadeiros, o resultado será:

      Output

      true yes
      • Se, porém, a statement1 for avaliada como verdadeira, mas a nested_statement for avaliada como falsa, então o resultado será:

      Output

      true no
      • E,caso a statement1 for avaliada como falsa, a instrução if-else aninhada não será executada, de modo que a instrução else será executada sozinha e o resultado será:

      Output

      false

      Também podemos ter várias instruções if aninhadas ao longo do nosso código:

      if statement1 { // outer if
          fmt.Println("hello world")
      
          if nested_statement1 { // first nested if
              fmt.Println("yes")
      
          } else if nested_statement2 { // first nested else if
              fmt.Println("maybe")
      
          } else { // first nested else
              fmt.Println("no")
          }
      
      } else if statement2 { // outer else if
          fmt.Println("hello galaxy")
      
          if nested_statement3 { // second nested if
              fmt.Println("yes")
          } else if nested_statement4 { // second nested else if
              fmt.Println("maybe")
          } else { // second nested else
              fmt.Println("no")
          }
      
      } else { // outer else
          statement("hello universe")
      }
      

      Neste código, há uma instrução if aninhada dentro de cada instrução if, além da instrução else if. Isso permitirá mais opções dentro de cada condição.

      Vamos examinar um exemplo de instruções if aninhadas com nosso programa grade.go. Podemos verificar primeiro se uma nota é de aprovação (maior ou igual a 65%) e, então, avaliar a qual nota alfabética a nota numérica deve equivaler. No entanto, se a nota não for de aprovação, não precisaremos executar pela avaliação alfabética. Em vez disso, poderemos ter o relatório do programa de que a avaliação foi de desaprovação. Nosso código modificado com a instrução if aninhada se parecerá com este:

      grade.go

      
      package main
      
      import "fmt"
      
      func main() {
          grade := 92
          if grade >= 65 {
              fmt.Print("Passing grade of: ")
      
              if grade >= 90 {
                  fmt.Println("A")
      
              } else if grade >= 80 {
                  fmt.Println("B")
      
              } else if grade >= 70 {
                  fmt.Println("C")
      
              } else if grade >= 65 {
                  fmt.Println("D")
              }
      
          } else {
              fmt.Println("Failing grade")
          }
      }
      

      Se executarmos o código com a variável grade definida como o valor de númer o inteiro 92, a primeira condição será cumprida e o programa irá imprimir Passing grade of: . Em seguida, ele irá verificar se a nota é maior ou igual a 90 e, como essa condição também é cumprida, irá imprimir A.

      Se executarmos o código com a variável grade definida em 60, significa que a primeira condição não foi cumprida e, assim, o programa irá ignorar as instruções if aninhadas e prosseguirá com a instrução else e o programa imprimirá Failing grade.

      É claro que podemos adicionar ainda mais opções a isso e usar uma segunda camada de instruções if aninhadas. Talvez queiramos avaliar em relação às notas de A+, A e A- separadamente. Podemos fazer isso primeiro verificando se a nota é de aprovação; depois, verificando para saber se a nota é 90 ou acima e, em seguida, verificando se a nota está acima de 96 em relação a uma avaliação de A+:

      grade.go

      ...
      if grade >= 65 {
          fmt.Print("Passing grade of: ")
      
          if grade >= 90 {
              if grade > 96 {
                  fmt.Println("A+")
      
              } else if grade > 93 && grade <= 96 {
                  fmt.Println("A")
      
              } else {
                  fmt.Println("A-")
              }
      ...
      

      Neste código, para uma variável grade definida em 96, o programa irá executar o seguinte:

      1. Verificar se a nota é maior ou igual a 65 (verdadeiro)
      2. Imprimir Passing grade of:
      3. Verificar se a nota é maior ou igual a 90 (verdadeiro)
      4. Verificar se a nota é maior que 96 (falso)
      5. Verificar se a nota é maior que 93 e também menor ou igual a 96 (verdadeiro)
      6. Imprimir A
      7. Saia dessas instruções condicionais aninhadas e continue com o código restante

      Portanto, o resultado do programa para uma nota 96 se parece com este:

      Output

      Passing grade of: A

      As instruções if aninhadas podem dar a oportunidade de adicionar diversos níveis específicos de condições ao seu código.

      Conclusão

      Ao usar instruções condicionais como a instrução if, você terá maior controle sobre o que seu programa executa. As instruções condicionais dizem ao programa para avaliar se uma certa condição está sendo cumprida. Se a condição for cumprida, o programa irá executar o código específico; mas, se não for cumprida, o programa continuará passando para outro código.

      Para continuar praticando instruções condicionais, tente usar operadores diferentes para adquirir maior familiaridade com as instruções condicionais.



      Source link

      Como escrever instruções switch em Go


      Introdução

      As instruções condicionais dão aos programadores capacidade para direcionar seus programas a tomarem algumas medidas se uma condição for verdadeira e outra ação se a condição for falsa. Frequentemente, queremos comparar algumas variáveis com vários valores possíveis, tomando diferentes ações em cada circunstância. É possível fazer isso funcionar usando somente as instruções if. No entanto, escrever um software não diz respeito somente a fazer as coisas funcionarem, mas também de comunicar sua intenção para outros desenvolvedores e para si mesmo no futuro. O switch é uma instrução condicional alternativa útil para comunicar as ações tomadas pelos seus programas em Go quando diante de diferentes opções.

      Tudo o que podemos escrever com a instrução switch também pode ser escrito com as instruções if. Neste tutorial, vamos examinar alguns exemplos do que a instrução switch pode fazer, quais instruções if ela substitui e onde ela é mais adequadamente aplicada.

      Estrutura das instruções switch

      A instrução switch é geralmente usada para descrever as ações tomadas por um programa quando atribuímos valores específicos para uma variável. O exemplo a seguir demonstra como realizaríamos isso usando instruções if:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              if flav == "strawberry" {
                  fmt.Println(flav, "is my favorite!")
                  continue
              }
      
              if flav == "vanilla" {
                  fmt.Println(flav, "is great!")
                  continue
              }
      
              if flav == "chocolate" {
                  fmt.Println(flav, "is great!")
                  continue
              }
      
              fmt.Println("I've never tried", flav, "before")
          }
      }
      

      Isso gerará o seguinte resultado:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! I've never tried banana before

      Dentro de main, definimos uma fatia com sabores de sorvete. Na sequência, usamos um for loop para iterar por eles. Usamos três instruções if para imprimir diferentes mensagens que indicam preferências por diferentes sabores de sorvete. Cada instrução if deve usar a instrução continue para parar a execução do loop for, de modo que a mensagem padrão no final não seja impressa em relação aos sabores preferidos de sorvete.

      À medida que adicionamos novas preferências de sorvete, temos que continuar adicionando instruções if para lidar com os novos casos. As mensagens duplicadas, como no caso de "vanilla" e "chocolate", devem ter instruções if duplicadas. Para futuros leitores do nosso código (nós mesmos, inclusive), a natureza repetitiva das instruções if atrapalha o entendimento sobre parte importante do que elas estão fazendo — comparando a variável com vários valores e tomando diferentes ações. Além disso, nossa mensagem de fallback fica separada das condicionais, fazendo-a parecer não relacionada. A instrução switch pode nos ajudar a organizar essa lógica melhor.

      A instrução switch começa com a palavra-chave switch e é seguida, em sua forma mais básica, de algumas variáveis com as quais serão feitas comparações. Após a instrução vem um par de chaves ({}) onde várias cláusulas de caso podem aparecer. As cláusulas de caso descrevem as medidas que o seu programa em Go deve adotar quando a variável informada à instrução switch for igual ao valor referenciado pela cláusula de caso. O exemplo a seguir converte o exemplo anterior para que use uma switch em vez de várias instruções if:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              switch flav {
              case "strawberry":
                  fmt.Println(flav, "is my favorite!")
              case "vanilla", "chocolate":
                  fmt.Println(flav, "is great!")
              default:
                  fmt.Println("I've never tried", flav, "before")
              }
          }
      }
      

      O resultado é o mesmo de antes:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! I've never tried banana before

      Mais uma vez, definimos uma fatia com sabores de sorvete em main e usamos a instrução range para iterar sobre cada sabor. Dessa vez, no entanto, usamos uma instrução switch que irá examinar a variável flav. Usamos duas cláusulas case para indicar as preferências. Já não precisamos de instruções continue, já que apenas uma cláusula case será executada pela instrução switch. Também podemos combinar a lógica duplicada das condicionais "chocolate" e "vanilla", separando cada uma com uma vírgula na declaração da cláusula case. A cláusula default serve como nossa cláusula catch-all [global]. Ela executará em relação a todos os sabores que ainda não foram contabilizados no corpo da instrução switch. Nesse caso, "banana" fará com que default seja executada, imprimindo a mensagem I've never tried banana before (Nunca experimentei o de banana antes).

      Essa forma simplificada de instruções switch lida com o uso mais comum dado a elas: comparar uma variável com várias alternativas. Ela também nos traz conveniência nos locais em que queremos tomar a mesma medida em relação a diversos valores diferentes e algumas outras medidas quando nenhuma das condições listadas forem atendidas pelo uso da palavra-chave default informada.

      Quando essa forma simplificada da switch mostra-se limitada, podemos usar uma forma mais geral da instrução switch.

      Instruções switch gerais

      As instruções switch são úteis para agrupar coleções de condicionais mais complicadas, mostrando que elas estão de alguma maneira relacionadas. Isso é mais comumente usado ao comparar algumas variáveis com uma gama de valores, em vez de valores específicos, como no exemplo anterior. O exemplo a seguir implementa um jogo de adivinhação usando instruções if que poderia ser beneficiado por uma instrução switch:

      package main
      
      import (
          "fmt"
          "math/rand"
          "time"
      )
      
      func main() {
          rand.Seed(time.Now().UnixNano())
          target := rand.Intn(100)
      
          for {
              var guess int
              fmt.Print("Enter a guess: ")
              _, err := fmt.Scanf("%d", &guess)
              if err != nil {
                  fmt.Println("Invalid guess: err:", err)
                  continue
              }
      
              if guess > target {
                  fmt.Println("Too high!")
                  continue
              }
      
              if guess < target {
                  fmt.Println("Too low!")
                  continue
              }
      
              fmt.Println("You win!")
              break
          }
      }
      

      O resultado variará dependendo do número aleatório selecionado e do quão bem você jogar o jogo. Aqui está o resultado de uma sessão para exemplificar:

      Output

      Enter a guess: 10 Too low! Enter a guess: 15 Too low! Enter a guess: 18 Too high! Enter a guess: 17 You win!

      Nosso jogo de adivinhação precisa de um número aleatório contra o qual fazer as comparações. Portanto, usamos a função rand.Intn do pacote math/rand. Para garantir que obteremos diferentes valores para target toda vez que jogarmos o jogo, usamos o rand.Seed para aplicar um fator de aleatoriedade ao gerador de números aleatórios, com base no momento atual. O argumento 100 para rand.Intn nos dará um número no intervalo de 0-100. Então, usamos um loop for para começar a coletar adivinhações do jogador.

      A função fmt.Scanf nos oferece um meio para ler a entrada do usuário em uma variável de nossa escolha. Ela usa um verbo para a string de formato, a qual converte a entrada do usuário para o tipo que esperamos. O %d aqui significa que esperamos um int e enviamos o endereço da variável guess para que o fmt.Scanf consiga definir tal variável. Após lidar com quaisquer erros de análise, usamos duas instruções if para comparar a adivinhação do usuário com o valor target. A string que elas retornam, junto com o bool [booleano], controla a mensagem exibida para o jogador e também se o jogo fechará.

      Essas instruções if tornam vago o fato de que o intervalo de valores com o qual a variável está sendo comparada são todos relacionados de alguma maneira. À primeira vista, pode ser difícil dizer se perdemos alguma parte do intervalo. O exemplo a seguir refatora o exemplo anterior para usar uma instrução switch como alternativa:

      package main
      
      import (
          "fmt"
          "math/rand"
      )
      
      func main() {
          target := rand.Intn(100)
      
          for {
              var guess int
              fmt.Print("Enter a guess: ")
              _, err := fmt.Scanf("%d", &guess)
              if err != nil {
                  fmt.Println("Invalid guess: err:", err)
                  continue
              }
      
              switch {
              case guess > target:
                  fmt.Println("Too high!")
              case guess < target:
                  fmt.Println("Too low!")
              default:
                  fmt.Println("You win!")
                  return
              }
          }
      }
      

      Isso gerará um resultado similar ao seguinte:

      Output

      Enter a guess: 25 Too low! Enter a guess: 28 Too high! Enter a guess: 27 You win!

      Nessa versão do jogo de adivinhação, substituímos o bloco de instruções if por uma instrução switch. Omitimos o argumento da expressão para switch porque somente estamos interessados em usar a instrução switch para coletar condicionais juntas. Cada cláusula case contém uma expressão diferente que compara o guess com o target. De maneira similar à primeira vez que substituímos instruções if pela switch, já não precisamos mais de instruções continue, já que apenas uma cláusula case será executada. Por fim, a cláusula default lida com o caso onde o guess == target, uma vez que cobrimos todos os outros valores possíveis com outras duas cláusulas case.

      Nos exemplos que vimos até agora, será executada exatamente uma instrução case. De vez em quando, você pode desejar combinar os comportamentos das várias cláusulas case. As instruções switch fornecem outra palavra-chave para alcançar este comportamento.

      Fallthrough

      As vezes será necessário reutilizar o código que outra cláusula case contém. Nesses casos, é possível pedir ao Go que execute o corpo da próxima cláusula case listada usando a palavra-chave fallthrough. Este próximo exemplo modifica nosso exemplo anterior de sabor de sorvete para refletir com maior precisão nosso entusiasmo por sorvete de morango:

      package main
      
      import "fmt"
      
      func main() {
          flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}
      
          for _, flav := range flavors {
              switch flav {
              case "strawberry":
                  fmt.Println(flav, "is my favorite!")
                  fallthrough
              case "vanilla", "chocolate":
                  fmt.Println(flav, "is great!")
              default:
                  fmt.Println("I've never tried", flav, "before")
              }
          }
      }
      

      Vamos ver este resultado:

      Output

      chocolate is great! vanilla is great! strawberry is my favorite! strawberry is great! I've never tried banana before

      Como vimos anteriormente, definimos uma fatia da string para representar sabores e iterar ao longo dela usando um loop for. A instrução switch aqui é idêntica à que já vimos antes, porém com a adição da palavra-chave fallthrough ao final da cláusula case para "strawberry". Isso faz com que o Go execute o corpo de case "strawberry":, primeiro imprimindo a string strawberry is my favorite! (morango é o meu predileto!). Quando encontrar a palavra-chave fallthrough, executará o corpo da próxima cláusula case. Isso faz com que o corpo do case "vanilla", "chocolate" execute, imprimindo strawberry is great! (morango é uma ótimo!).

      A palavra-chave fallthrough não é usada frequentemente pelos desenvolvedores de Go. Normalmente, a reutilização de código realizada usando a palavra-chave fallthrough pode ser obtida de maneira melhor definindo-se uma função com o código comum. Por essas razões, o uso da palavra-chave fallthrough, no geral, é desencorajado.

      Conclusão

      As instruções switch nos ajudam a transmitir para outros desenvolvedores que leem nosso código que em um conjunto de comparações, elas estão de alguma maneira relacionadas. Elas facilitarão muito mais quando tivermos que adicionar comportamentos diferentes se um novo caso for adicionado no futuro e possibilitarão a garantia de que tudo o que esquecermos será devidamente tratato apropriadamente com as cláusulas default. A próxima vez que você se encontrar escrevendo várias instruções if, sendo que todas envolvem a mesma variável, tente reescrevê-las com uma instrução switch — será mais fácil revisar o trabalho quando for hora de considerar algum outro valor alternativo.

      Se quiser aprender mais sobre a linguagem de programação Go, confira toda a série sobre Como codificar na série Go.



      Source link

      Usando instruções break e continue ao trabalhar com loops em Go


      Introdução

      O uso de loops do tipo “for” em Go permite que você automatize e repita tarefas de maneira eficiente.

      Aprender como controlar a operação e o fluxo dos loops permitirá uma lógica personalizada em seu programa. É possível controlar seus loops com as instruções break [interromper] e continue [continuar].

      Instrução break

      Em Go, a instrução break termina a execução do loop atual. Uma break está quase sempre pareada com uma instrução condicional if.

      Vamos ver um exemplo que usa a instrução break em um loop do tipo "for":

      break.go

      package main
      
      import "fmt"
      
      func main() {
          for i := 0; i < 10; i++ {
              if i == 5 {
                  fmt.Println("Breaking out of loop")
                  break // break here
              }
              fmt.Println("The value of i is", i)
          }
          fmt.Println("Exiting program")
      }
      

      Este pequeno programa cria um loop do tipo "for" que irá iterar enquanto i for menor que 10.

      Dentro do loop do tipo "for", há uma instrução if. A instrução if testa a condição de i para ver se o valor é menor que 5. Se o valor i não for igual a 5, o loop continua e imprime o valor de i. Se o valor de i for igual a 5, o loop irá executar a instrução break, imprimir que ele está Breaking out of loop [Saindo do loop] e parar de executar o loop. Ao final do programa, imprimimos Exiting program [Saindo do programa] para exprimir que saímos do loop.

      Quando executarmos esse código, nosso resultado será o seguinte:

      Output

      The value of i is 0 The value of i is 1 The value of i is 2 The value of i is 3 The value of i is 4 Breaking out of loop Exiting program

      Isso mostra que, uma vez que o número inteiro i é avaliado como equivalente a 5, o loop interrompe, uma vez que o programa é orientado a fazer isso com a instrução break.

      Loops aninhados

      É importante lembrar que a instrução break irá parar apenas a execução do loop mais interno em que for chamada. Se tiver um conjunto aninhado de loops, será necessário uma interrupção para cada loop se desejar.

      nested.go

      package main
      
      import "fmt"
      
      func main() {
          for outer := 0; outer < 5; outer++ {
              if outer == 3 {
                  fmt.Println("Breaking out of outer loop")
                  break // break here
              }
              fmt.Println("The value of outer is", outer)
              for inner := 0; inner < 5; inner++ {
                  if inner == 2 {
                      fmt.Println("Breaking out of inner loop")
                      break // break here
                  }
                  fmt.Println("The value of inner is", inner)
              }
          }
          fmt.Println("Exiting program")
      }
      

      Neste programa, temos dois loops. Embora ambos iterem 5 vezes, cada um tem uma instrução condicional if com uma instrução break. O loop exterior será interrompido se o valor outer for igual a 3. O loop interno será interrompido se o valor inner for 2.

      Se executarmos o programa, veremos o seguinte resultado:

      Output

      The value of outer is 0 The value of inner is 0 The value of inner is 1 Breaking out of inner loop The value of outer is 1 The value of inner is 0 The value of inner is 1 Breaking out of inner loop The value of outer is 2 The value of inner is 0 The value of inner is 1 Breaking out of inner loop Breaking out of outer loop Exiting program

      Note que cada vez que o loop interno é interrompido, o loop exterior não é. Isso acontece porque o break irá interromper apenas o loop mais interno de onde for chamado.

      Vimos de que maneira o uso da instrução break irá interromper a execução de um loop. Em seguida, vamos ver como é possível continuar a iteração de um loop.

      Instrução continue

      A instrução continue é usada quando você quer pular a parte restante do loop, retornar ao topo do loop e dar continuidade a uma nova iteração.

      Tal como com a instrução break, a instrução continue é comumente usada com uma instrução condicional if.

      Usando o mesmo programa de loop do tipo "for" que na seção anterior da Instrução break, usaremos uma instrução continue, em vez de uma instrução break:

      continue.go

      package main
      
      import "fmt"
      
      func main() {
          for i := 0; i < 10; i++ {
              if i == 5 {
                  fmt.Println("Continuing loop")
                  continue // break here
              }
              fmt.Println("The value of i is", i)
          }
          fmt.Println("Exiting program")
      }
      

      A diferença entre usar a instrução continue, em vez de uma instrução break, é que o nosso código continuará apesar da interrupção quando a variável i for avaliada como equivalente a 5. Vamos ver nosso resultado:

      Output

      The value of i is 0 The value of i is 1 The value of i is 2 The value of i is 3 The value of i is 4 Continuing loop The value of i is 6 The value of i is 7 The value of i is 8 The value of i is 9 Exiting program

      Aqui, vemos que a linha The value of i is 5 [O valor de i é 5] nunca ocorre no resultado, mas o loop continua após aquele ponto para imprimir linhas para os números 6-10 antes de sair do loop.

      Você pode usar a instrução continue para evitar um código condicional extremamente aninhado, ou para otimizar um loop, eliminando casos que ocorram com frequência e que você gostaria de rejeitar.

      A instrução continue faz com que um programa pule certos fatores que surjam dentro de um loop, mas depois continuem pelo restante do loop.

      Conclusão

      As instruções break e continue em Go permitirão que você use loops do tipo "for" de maneira mais eficaz em seu código.



      Source link