Base de Conhecimento

Introdução

Instruções condicionais fazem parte de toda linguagem de programação. Com instruções condicionais, podemos ter código que algumas vezes é executado e outras não, dependendo das condições do programa naquele momento.

Quando executamos completamente cada instrução de um programa, não estamos solicitando que o programa avalie condições específicas. Usando instruções condicionais, os programas podem determinar se determinadas condições estão sendo atendidas e, em seguida, saber o que fazer em seguida.

Vejamos alguns exemplos em que usaríamos declarações condicionais:

• Se o aluno receber mais de 65% em seu teste, informe que sua nota passa; caso contrário, relate que a nota dela falha.
• Se ele tiver dinheiro em sua conta, calcule os juros; se não, cobrar uma taxa de penalidade.
• Se eles comprarem 10 laranjas ou mais, calcule um desconto de 5%; se eles compram menos, então não.

Ao avaliar as condições e atribuir o código a ser executado com base no cumprimento ou não dessas condições, estamos escrevendo um código condicional.

Este tutorial orientará você na criação de instruções condicionais na linguagem de programação Go.

Instruções If

Começaremos com a ifinstrução, que avaliará se uma instrução é verdadeira ou falsa e executaremos o código apenas no caso de a instrução ser verdadeira.

Em um editor de texto sem formatação, abra um arquivo e escreva o seguinte código:

package main

import "fmt"

func main() {
    grade := 70

    if grade >= 65 {
        fmt.Println("Passing grade")
    }
}

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

Salve o programa como grade.goe executá-lo em um ambiente de programação local a partir de uma janela do terminal com o comando go run grade.go.

Neste caso, o grau de 70 não satisfazem a condição de ser maior ou igual a 65, então você receberá a seguinte saída uma vez que você executar o programa:

Passing grade

Vamos agora mudar o resultado desse programa, alterando o valor da gradevariável para 60:

package main

import "fmt"

func main() {
    grade := 60

    if grade >= 65 {
        fmt.Println("Passing grade")
    }
}

Quando salvamos e executamos esse código, não receberemos saída porque a condição não foi atendida e não informamos ao programa para executar outra instrução.

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

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 executamos o programa go run account.go, receberemos a seguinte saída:

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

No programa, inicializamos a variável balancecom o valor de -5, que é menor que 0. Como o saldo atendeu à condição da ifinstrução ( balance < 0), depois que salvar e executar o código, receberemos a saída da string. Novamente, se alterarmos o saldo para 0 ou um número positivo, não receberemos saída.

Declarações Else

É provável que desejemos que o programa faça algo mesmo quando uma ifdeclaração for avaliada como falsa. Em nosso exemplo de nota, queremos que a saída seja aprovada ou reprovada.

Para fazer isso, adicionaremos uma elsedeclaração à condição de classificação acima, construída dessa maneira:

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 classificação tem o valor de 60, a ifinstrução é avaliada como falsa, para que o programa não seja impresso Passing grade. A elsedeclaração a seguir informa o programa para fazer algo de qualquer maneira.

Quando salvarmos e executarmos o programa, receberemos a seguinte saída:

Failing grade

Se reescrevermos o programa para atribuir à nota um valor igual 65ou superior, receberemos a saída Passing grade.

Para adicionar um elseextrato ao exemplo da conta bancária, reescrevemos o código da seguinte maneira:

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.")
    }
}

Your balance is 0 or above.

Aqui, alteramos o balancevalor da variável para um número positivo para que a elseinstrução seja impressa. Para obter a primeira ifinstrução a ser impressa, podemos reescrever o valor para um número negativo.

Ao combinar uma ifinstrução com uma elseinstrução, você está construindo uma instrução condicional de duas partes que instruirá o computador a executar determinado código, independentemente de a ifcondição ser ou não atendida.

Senão se declarações

Até agora, apresentamos uma opção booleana para declarações condicionais, com cada ifdeclaração avaliada como verdadeira ou falsa. Em muitos casos, queremos um programa que avalie mais de dois resultados possíveis. Para isso, usaremos uma declaração else if , escrita em Go as else if. A else ifinstrução or if se parece com a ifinstrução e avaliará outra condição.

No programa de conta bancária, podemos ter três saídas discretas para três situações diferentes:

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

A else ifdeclaração será colocada entre a ifdeclaração e a elsedeclaração da seguinte maneira:

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, existem três saídas possíveis que podem ocorrer após a execução do programa:

• Se a variável balancefor igual a 0, receberemos a saída da else ifinstrução ( Balance is equal to 0, add funds soon.)
• Se a variável balanceestiver definida como um número positivo, receberemos a saída da elseinstrução ( Your balance is 0 or above.).
• Se a variável balanceestiver definida como um número negativo, a saída será a string da ifinstrução ( Balance is below 0, add funds now or you will be charged a penalty).

E se quisermos ter mais de três possibilidades? Podemos fazer isso escrevendo mais de uma else ifdeclaração em nosso código.

No grade.goprograma, vamos reescrever o código para que haja algumas notas de letras correspondentes a intervalos de notas numéricas:

• 90 ou acima é equivalente a uma classe A
• 80-89 é equivalente a uma classe B
• 70-79 é equivalente a uma classe C
• 65-69 é equivalente a um grau D
• 64 ou menos é equivalente a um grau F

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

Vamos reescrever o código do exemplo anterior para ter strings que imprimem cada uma das notas das letras. Podemos manter a nossa elsedeclaração da mesma forma.

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 else ifdeclarações serão avaliadas em ordem, podemos mantê-las bastante básicas. Este programa está concluindo as seguintes etapas:

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

2. Se a nota for maior ou igual a 80, o programa será impresso B grade; se a nota for 79 ou menos, o programa continuará com a próxima declaração…

3. Se a nota for maior ou igual a 70, o programa será impresso C grade; se a nota for 69 ou menos, o programa continuará com a próxima declaração…

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

5. O programa será impresso Failing gradeporque todas as condições acima não foram atendidas.

Instruções If aninhadas

Uma vez que você está se sentindo confortável com os if, else ife elsedeclarações, você pode passar para declarações condicionais aninhadas. Podemos usar ifinstruções aninhadas para situações em que queremos verificar uma condição secundária se a primeira condição for executada como verdadeira. Para isso, podemos ter uma instrução if-else dentro de outra instrução if-else. Vejamos a sintaxe de uma ifinstrução 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")
}

Algumas saídas possíveis podem resultar deste código:

• Se statement1avaliado como verdadeiro, o programa avaliará se o nested_statementtambém é avaliado como verdadeiro. Se ambos os casos forem verdadeiros, a saída será:

Output

true
yes

• Se, no entanto, for statement1avaliado como verdadeiro, mas for nested_statementfalso, a saída será:

Output

true
no

• E se for statement1avaliado como false, a instrução if-else aninhada não será executada, portanto, a elseinstrução será executada sozinha e a saída será:

Output

false

Também podemos ter várias ifinstruções aninhadas em todo o 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")
}

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

Vejamos um exemplo de ifinstruções aninhadas com o nosso grade.goprograma. Podemos verificar se uma nota está sendo aprovada primeiro (maior ou igual a 65%) e depois avaliar em qual nota a qual a nota numérica deve ser equivalente. Se a nota não for aprovada, porém, não precisamos ler as notas das cartas e, em vez disso, poderemos informar o programa que a nota está falhando. Nosso código modificado com a ifinstrução aninhada ficará assim:

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 gradedefinida como o valor inteiro 92, a primeira condição será atendida e o programa será impresso Passing grade of:. Em seguida, ele verificará se a nota é maior ou igual a 90 e, como essa condição também é atendida, ela será impressa A.

Se executarmos o código com a gradevariável definida como 60, a primeira condição não será atendida; portanto, o programa ignorará as ifinstruções aninhadas e passará para a elseinstrução, com a impressão do programa Failing grade.

É claro que podemos adicionar ainda mais opções a isso e usar uma segunda camada de instruções if aninhadas. Talvez desejemos avaliar as notas de A +, A e A- separadamente. Podemos fazer isso verificando primeiro se a nota está passando, depois verificando se a nota é 90 ou superior e depois verificando se a nota está acima de 96 para um A +:

...
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-")
        }
...

Nesse código, para uma gradevariável definida como 96, o programa executará o seguinte:

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

A saída do programa para uma nota de 96, portanto, é assim:

Passing grade of: A

Instruções aninhadas ifpodem fornecer a oportunidade de adicionar vários níveis específicos de condições ao seu código.

Conclusão

Usando instruções condicionais como a ifinstrução, você terá maior controle sobre o que seu programa executa. Instruções condicionais dizem ao programa para avaliar se uma determinada condição está sendo atendida. Se a condição for atendida, ele executará um código específico, mas se não for atendido, o programa continuará passando para outro código.