One place for hosting & domains

      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