if e operadores relacionais em Golang
Tags: go, beginners, tutorial
Published: 2020-05-25 22:36:43

Então prontos para mais um post?

Hoje vamos falar sobre o **fluxo de controle condicional** e **operadores relacionais**.

Primeiros temos que entender o que é uma condição. Segundo o google: *"Condição é o que determina, ou não, a realização de alguma coisa".* Exemplos:

- **Se fizer sol, vou a praia, se não fizer, ficarei em casa**

Aqui a condição é fazer sol. Se fizer sol, a pessoa vai sair, mas se não fizer, ou seja, se chover, ela ficará em casa.

- **Se ganhar na loteria, vou viajar o mundo, se não ganhar, vou ao cinema** 

Desta vez a condição é ganhar na loteria. 

É uma lógica fácil e que todos utilizam no dia a dia, mesmo sem perceber. Agora vamos aplica-la na linguagem de programação.

```golang

var fizerSol bool

if fizerSol == true {
    fmt.Println("Vou a praia")

} else {
   fmt.Println("Ficarei em casa")

}
```
Vamos analisar o código parte por parte.

``fizerSol`` é uma variável booleana, ou seja, só aceita ``true`` ou ``false``.

``if`` literalmente significa "se". Então ele deve sempre estar acompanhado de uma condição, "se isso acontecer... se não...".

``fizerSol == true``, essa é a condição que acompanha o ``if``. Se ela for verdadeira (true), então o código que está no code block do ``if`` será executado. 

```golang

fizerSol := true //Está fazendo sol

if fizerSol == true { //A condição é verdadeira
    fmt.Println("Vou a praia") //Esse código será executado 
} 
```

``else`` é o nosso "se não". Ele só será executado se a condição do ``if`` for falsa, ou seja, não esteja fazendo sol.

```golang

fizerSol := false //Está chovendo

if fizerSol == true { //A condição é false
    fmt.Println("Vou a praia") //Esse código não será executado

}  else { 
    fmt.Println("Ficarei em casa")//Esse código será executado
}
```
Nós também podemos criar várias condições em sequência com o ``else if``. 

```golang

fizerSol := false 
tenhoDinheiro := true


if fizerSol == true { 
    fmt.Println("Vou a praia") 

}  else if tenhoDiheiro == true { //Condição verdadeira
    fmt.Println("Vou ao cinema")//Esse código será executado

} else  { 
    fmt.Println("Ficarei em casa")
}
```

Agora além da condição do sol, temos a condição do dinheiro. 
*"Se fizer sol, vou a praia, se não fizer, ok* 🤷🏽‍♀️*... Eu ainda posso ir ao cinema, contanto que tenha dinheiro. Se eu não tiver dinheiro, ai não tem jeito, vou ficar em casa"*

Ainda podemos colocar mais condições:

```golang

fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false //Não é dia da semana


if fizerSol == true { 
    fmt.Println("Vou a praia") 

}  else if tenhoDiheiro == true { //Condição verdadeira

    if diaDaSemana == true { //Condição falsa
        fmt.Println("Vou ao cinema")
    } else { 
        fmt.Println("Vou a festa")//Esse código será executado 
    }
} else  { 
    fmt.Println("Ficarei em casa")
}
```

A lógica é a seguinte:

*"Se fizer sol, vou a praia, se não fizer, ok* 🤷🏽‍♀️*... Se eu tiver dinheiro e for dia da semana, vou ao cinema. Se eu tiver dinheiro e não for dia da semana, vou a festa. Se eu não tiver dinheiro, fico em casa"*

Agora que entendemos a lógica, vamos falar desse carinha aqui: ``==``. Já percebemos que ele tem o sentido de igual, mas estamos utilizando dois iguais ao invés de um. Isso acontece porque ele esta em uma condição.

Quando falamos: ``tenhoDinheiro = true``, estou atribuindo um valor a variável. Quando estamos em uma condição, não queremos atribuir valor, queremos comparar duas coisas, relacionar elas. Então para não confundir, utilizamos dois iguais ``==``. Ele é chamado de operador relacional.

Um detalhe é que podemos tirar ele da condição, pois por padrão só iremos entrar no ``if`` se a variável for verdadeira, ``true``. O efeito é o mesmo e ainda deixamos menos poluído.

```golang

fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false //Não é dia da semana


if fizerSol { 
    fmt.Println("Vou a praia") 

}  else if tenhoDiheiro { //Condição verdadeira

    if diaDaSemana { //Condição falsa
        fmt.Println("Vou ao cinema")
    } else { 
        fmt.Println("Vou a festa")//Esse código será executado 
    }
} else  { 
    fmt.Println("Ficarei em casa")
}
```

Existem outros operadores relacionais, são eles:

- ``<`` - Menor
- ``>`` - Maior
- ``==`` - Comparação
- ``<=`` - Menor ou igual
- ``>=`` - Maior ou igual
- ``!=`` - Diferente


**Menor e Maior**

Esses são mais utilizados no cotidiano. 
```golang

num1 := 10
num2 := 100

if num1 > num2{//false, 10 não é maior que 100
    fmt.Println(num1,"é maior que", num2) //Esse código não será executado

} 

if num1 < num2  { // true, 10 é menor que 100 
    fmt.Println(num1,"é maior que", num2) //Esse código será executado
}
```

**Menor ou igual e Maior ou igual**
```golang

num1 := 10
num2 := 100
num3 := 10

if num1 >= num2{//false, 10 não é maior, nem igual a 100
    fmt.Println(num1,"é maior ou igual a", num2) //Esse código não será executado
} 

if num1 <= num2  { // true, 10 é MENOR ou igual a 100 
    fmt.Println(num1,"é maior ou igual a", num2) //Esse código será executado
}

if num1 <= num3  { // true, 10 é menor ou IGUAL a 10
    fmt.Println(num1,"é menor ou igual a", num3) //Esse código também será executado
}
```

**Diferente**

```golang

num1 := 10
num2 := 100
num3 := 10

if num1 != num2{//true, 10 é diferente de 100
    fmt.Println(num1,"é diferente", num2) //Esse código será executado
}

if num1 != num3  { // false, 10 não é diferente de 10
    fmt.Println(num1,"diferente de", num3) //Esse código não será executado
}
```

Além dos operadores relacionais, temos os **Operadores lógicos**. Mas vamos conhece-los amanhã, junto a com a nossa querida **lógica booleana**.

Para não perder o costume...
Vai dar uma olhada nesse [curso](https://youtu.be/WiGU_ZB-u0w). Material de qualidade e gratuito para a comunidade 🤙🏽


**Fiquem bem, assistam muitas séries e até amanhã.**

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/xwj2bepmb9xuc4225zet.png)