Lógica booleana e operadores lógicos
Tags: beginners, tutorial, go
Published: 2020-05-26 23:27:18

**O assunto de hoje é bem básico, mas é muito importante na programação**.

Vamos começar falando da lógica booleana. 

*Curiosidade: O nome é em homenagem ao George Boole. Um matemático e criador da lógica booleana.*

A lógica booleana trabalha com ``true`` e ``false``, ``0`` e ``1``, ligado e desligado. São apenas dois valores opostos. Nenhuma novidade para nós, já trabalhamos com variáveis booleanas antes.

Bem, agora vamos entrar na parte da lógica...

Se eu falar: **Hoje eu vou a praia E ao cinema**
Necessariamente eu tenho que ir aos dois lugares. Se eu não for a praia, terei contado uma mentira. Se eu não for ao cinema, a frase também será falsa. Para a frase ser verdade, eu tenho que ir aos dois lugares. 

Mas se eu falar: **Hoje vou a praia OU ao cinema**
Eu só precisarei ir a um dos dois lugares para a frase ser verdade. Não importa qual dos dois, basta ir a praia ou ao cinema. 

O "E" e o "OU" são operadores lógicos. Eles são utilizados tanto no dia a dia, quanto na programação, a diferença é que não são representados da mesma forma.

- ``&&`` = "E"  
- ``||`` = "OU" 
- ``!`` = "NOT"


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

**Hoje eu vou a praia E ao cinema**
```golang

fuiPraia := true
fuiCinema := true

frase := fuiPraia && fuiCinema

fmt.Println("A frase é", frase)

//Resultaso: "A frase é true"

```

A frase é verdadeira, pois o operador lógico é o ``&&`` e as variaveis são ``true``. Um "E" só retornará verdade quando todos os elementos forem verdadeiros, ou seja, basta um ``false`` para a frase ser falsa.

```golang

fuiPraia := false
fuiCinema := true

frase := fuiPraia && fuiCinema

fmt.Println("A frase é", frase)

//Resultaso: "A frase é false"

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

O ``not`` é a negação de algo. Se uma variavel é ``true``, com o ``not`` ela passa a ser ``false``. Ele converte tudo para o oposto. 

```golang

fuiPraia := false
fuiCinema := true

frase := !fuiPraia && fuiCinema //estou negando a variável praia

fmt.Println("A frase é", frase)

//Resultaso: "A frase é true"

```
A praia tem seu valor ``false``, mas quando negamos, ela deixa se ser ``false`` e passa a ser ``true``. E como já vimos ``true && true = true`` 

```golang

fuiPraia := false
fuiCinema := true

frase := !fuiPraia && fuiCinema //estou negando a variável praia

fmt.Println("A frase é", !frase)//Estou negando a frase

//Resultaso: "A frase é false"

```
O valor da frase era ``true``, mas estamos negando, então passa a ser ``false``.

Agora vamos testar o ``&&`` e o ``!`` junto com um ``if``. Lembra do exemplo do post passado? 

{% link https://dev.to/linivecristine/if-e-operadores-relacionais-em-golang-21c4 %}

```golang
fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 


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

}  else if tenhoDinheiro { 

    if diaDaSemana { 
        fmt.Println("Vou ao cinema")
    } else { 
        fmt.Println("Vou a festa")
    }
} else  { 
    fmt.Println("Ficarei em casa")
}
```

Ele pode ficar bem mais legível utilizando um operador lógico.

```golang
fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 


if fizerSol && tenhoDinheiro && !diaDaSemana { 
    fmt.Println("Vou a praia") 

} else if tenhoDinheiro && diaDaSemana  { 
   fmt.Println("Vou ao cinema")

} else if tenhoDinheiro && !diaDaSemana{ 
        fmt.Println("Vou a festa")

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

/*
Resultado : Vou a festa
*/
```

Vamos analisar por partes...

```golang
fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 

/*Se fizer sol, e se eu tiver dinheiro e não for dia de semana, eu vou a praia*/
if fizerSol && tenhoDinheiro && !diaDaSemana { 
    fmt.Println("Vou a praia") 

} 
```
Infelizmente, não está fazendo sol, ``fizerSol := false``. Já sabemos que um ``false`` já basta para o ``&&`` ser falso. Então toda a condição do primeiro ``if`` será falsa. 

```golang
fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 

/*Se tiver dinheiro e for dia da semana, vou ao cinema*/
...else if tenhoDinheiro && diaDaSemana  { 
   fmt.Println("Vou ao cinema")

}
```
Eu tenho dinheiro 🙌🏽, ``tenhoDinheiro := true``, mas não é dia da semana ``diaDaSemana := false``. Basta um falso para a condição ser falsa, então não vou ao cinema.

```golang
fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 

/*Se tiver dinheiro e NÃO for dia da semana, vou a festa*/
...else if tenhoDinheiro && !diaDaSemana{ 
        fmt.Println("Vou a festa")

}
```

As duas variáveis são verdadeiras. Eu tenho dinheiro e não é dia da semana, então a condição é verdadeira e eu vou a festa 💁🏽‍♂️.

Para finalizar, vamos conhecer o "OU".

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

**Hoje vou a praia OU ao cinema**
```golang

fuiPraia := false
fuiCinema := true

frase := fuiPraia || fuiCinema 

fmt.Println("A frase é", frase)

//Resultaso: "A frase é true"
```

Diferente do "E" que precisa de duas verdades, no "OU" uma verdade basta. Só preciso ir a um dos dois ligares e a frase será verdadeira.

```golang

fuiPraia := false
fuiCinema := false

frase := !fuiPraia || fuiCinema //estou negando a variável praia

fmt.Println("A frase é", frase)

//Resultaso: "A frase é true"
```

```golang
fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 


if fizerSol || tenhoDinheiro || !diaDaSemana { 
    fmt.Println("Vou a praia") 

}

if tenhoDinheiro || diaDaSemana  { 
   fmt.Println("Vou ao cinema")

}

if tenhoDinheiro || !diaDaSemana{ 
        fmt.Println("Vou a festa")

}

/*
Resultado : 
Vou a praia
Vou ao cinema
Vou a festa
*/
```
 Todos os casos foram verdadeiros utilizando o ``||``, pois em cada condição tinha pelo menos uma verdade e uma verdade já basta. 

```golang
fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 

/* Se fizer sol OU eu tiver dinheiro OU não for dia da semana, vou a praia.
Não fez sol, mas eu tenho dinheiro e não é dia da semana*/ 
//   false         true             true          
if fizerSol || tenhoDinheiro || !diaDaSemana { 
    fmt.Println("Vou a praia") 
}

/*Se tiver dinheiro OU for dia da semana, vou a cinema.
Eu tenho dinheiro, mas não é dia da semana*/
//     true             false
if tenhoDinheiro || diaDaSemana  { 
   fmt.Println("Vou ao cinema")
}

/*Se eu tiver dinheiro ou não for dia da semana, vou a festa.
Tenho dinheiro e não é dia da semana*/
//   true               true
if tenhoDinheiro || !diaDaSemana{ 
        fmt.Println("Vou a festa")
}
```

Também podemos utilizar todos os operadores em uma condição:
```golang
fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 
noite := true


if (fizerSol && tenhoDinheiro) || !diaDaSemana {
	fmt.Println("Vou a praia")
}  
	
if (tenhoDinheiro || diaDaSemana) && (!fizerSol && !noite) {
	fmt.Println("Vou ao cinema")
}
	
if (tenhoDinheiro && !diaDaSemana) && noite {
	fmt.Println("Vou a festa")
}
```

Aqui misturamos todos os operadores, vocês conseguem descobrir qual será a resposta?

A resposta será: Vou a praia / Vou a festa.

Vamos analisar o código...
```golang
fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 
noite := true

/*Se fizer sol E eu tiver dinheiro, OU for dia da semana, vou a praia*/         
if (fizerSol && tenhoDinheiro) || !diaDaSemana {
	fmt.Println("Vou a praia")
}  

/*Se tiver dinheiro OU for dia da semana, E não fizer sol E não for noite, vou ao cinema*/	
if (tenhoDinheiro || diaDaSemana) && (!fizerSol && !noite) {
	fmt.Println("Vou ao cinema")
}

/*Se tiver dinheiro E não for dia da semana E for noite, vou a festa*/	
if (tenhoDinheiro && !diaDaSemana) && noite {
	fmt.Println("Vou a festa")
}
```

Como toda operação matemática, devemos começar pelos parênteses.

```golang
fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 
noite := true


//   (false  &&     true)     
//         false               ||     true  = true
if (fizerSol && tenhoDinheiro) || !diaDaSemana {
	fmt.Println("Vou a praia")
} 
 
//     (true      ||   false)         (true     &&   false)   
//               true             &&            false         = false	
if (tenhoDinheiro || diaDaSemana) && (!fizerSol && !noite) {
	fmt.Println("Vou ao cinema")
}

//     (true      ||   true)          
//               true             &&   true =  true
if (tenhoDinheiro && !diaDaSemana) && noite {
	fmt.Println("Vou a festa")
}
```

Espero que tenham entendido a lógica booleana, é um assunto que eu acho muito divertido.

Se quiserem me acompanhar nos estudos, [chema mais](https://youtu.be/WiGU_ZB-u0w) ✌🏽

**Espero que estejam bem e se puder, fiquem em casa** 🏡
**Até amanhã.**
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/ska3x6g92d8b42mn3zzn.gif)