# 7.4.1 - Estruturas condicionais

## 🚀 Aprofundando nas Estruturas Condicionais

Agora que você já entende o básico de `if`, `else if` e `else`, vamos explorar outras formas de **tomar decisões no JavaScript** e entender melhor como essas estruturas funcionam por dentro. 🧠✨

***

### 🎯 `switch case` – Quando há muitas opções

Às vezes, usamos muitos `else if` seguidos. O código pode ficar confuso... 😵‍💫\
É aí que o `switch` entra para salvar o dia! 🦸

#### 🧪 Exemplo: Escolher uma bebida

```javascript
let bebida = "suco";

switch (bebida) {
  case "café":
    console.log("Você escolheu café ☕");
    break;
  case "chá":
    console.log("Você escolheu chá 🍵");
    break;
  case "suco":
    console.log("Você escolheu suco 🧃");
    break;
  default:
    console.log("Escolha inválida ❌");
}
```

🧩 O que está acontecendo aqui:

* O `switch` compara `bebida`com cada `case`.
* Se encontrar uma combinação, executa o código daquele bloco.
* O `break` serve para **parar a execução** quando uma opção já foi atendida.
* O `default` é **como o `else`**: é usado quando nenhuma opção bate.

📝 Use `switch` quando você tiver **muitas comparações de igualdade** com o mesmo valor.

***

### ⚡ Operador Ternário – Tudo em uma linha!

Quer fazer uma verificação **rápida**? Use o **operador ternário**!

#### 📌 Forma:

```javascript
condição ? valorSeVerdadeiro : valorSeFalso;
```

#### ✅ Exemplo:

```javascript
let idade = 20;
let mensagem = idade >= 18 ? "Maior de idade 🧔" : "Menor de idade 👶";
console.log(mensagem);
```

💡 Ideal para **decisões simples**. Mas cuidado: **não use para lógica complexa**.

***

### ⚠️ Observação importante: *Parênteses são obrigatórios!*

Quando usamos `if`, `else if` ou `while`, a **condição sempre deve estar entre parênteses** `( )`.

#### ❌ Exemplo com erro:

```javascript
if idade >= 18 {
  console.log("Pode votar");
}
```

💥 Isso **não vai funcionar!** O JavaScript vai mostrar um erro como:

> `Uncaught SyntaxError: Unexpected identifier`

Isso porque a **sintaxe correta exige parênteses** para o JavaScript saber **onde começa e termina a condição**.

#### ✅ Forma correta:

```javascript
if (idade >= 18) {
  console.log("Pode votar");
}
```

💡 **Dica de memória:**\
Pense nos parênteses como os "ouvidos" da condição. O `if` só escuta o que está **dentro deles!** 👂😉

***

### 🧠 Como o computador entende as condições?

Quando você escreve:

```javascript
if (idade >= 18)
```

O computador **avalia** a condição usando **valores booleanos**: `true` (verdadeiro) ou `false` (falso).\
Só quando a condição for `true`, o bloco dentro do `if` será executado.

***

### 🧩 Observação: Como as condições são "avaliadas"?

Toda condição no `if`, `while`, ou outras estruturas parecidas, sempre **resulta em `true` ou `false`**. Isso vale tanto para condições simples quanto para **condições compostas** com operadores.

#### 🔍 Exemplo 1: Condição simples

```javascript
let idade = 20;

console.log(idade >= 18); // true
```

📢 Aqui o computador está perguntando:\
\&#xNAN;**“20 é maior ou igual a 18?”**\
A resposta é `true` ✅

***

#### 🔗 Exemplo 2: Condição composta com `&&` (E)

```javascript
let idade = 20;
let temRG = true;

console.log(idade >= 18 && temRG); // true
```

O computador avalia **ambas as condições**:

* idade ≥ 18? ✅
* temRG? ✅

Como **ambas são verdadeiras**, o resultado da condição completa é `true` ✅

***

#### 🔀 Exemplo 3: Condição composta com `||` (OU)

```javascript
let temRG = false;
let temPassaporte = true;

console.log(temRG || temPassaporte); // true
```

Basta **uma das condições ser verdadeira** para que o resultado seja `true`.\
Aqui: RG ❌ mas passaporte ✅ → então a condição geral é **verdadeira**.

***

#### 🧠 Lembre-se:

| Expressão                     | Resultado |
| ----------------------------- | --------- |
| `true && true`                | ✅ `true`  |
| `true && false`               | ❌ `false` |
| `false && false`              | ❌ `false` |
| `true \|\| true`              | ✅`true`   |
| `true \|\| false`             | ✅`true`   |
| `false \|\| false`            | ❌ `false` |
| `!true`                       | ❌ `false` |
| `!(idade >= 18)` → idade = 20 | ❌ `false` |

🧪 Isso vale mesmo que a condição seja mais longa:

```javascript
if ((idade >= 18 && temRG) || temPassaporte) {
  // executa se for maior de idade e tiver RG, ou se tiver passaporte
}
```

💡 **Dica:** Para testar condições, você pode usar o `console.log()` e ver se o resultado é `true` ou `false`. É uma ótima forma de praticar! 🎯

***

### ⚠️ Redundância: evite repetir o que não precisa!

Veja este exemplo:

```javascript
if (isAluno === true) {
  console.log("É aluno");
}
```

🔁 **Redundante!** `isAluno` já é um valor booleano. O ideal seria:

```javascript
if (isAluno) {
  console.log("É aluno");
}
```

🧼 Deixar o código **limpo e direto** é sinal de **boas práticas**!

***

### 🔍 Quando usar qual estrutura?

| Situação                                           | Estrutura ideal         |
| -------------------------------------------------- | ----------------------- |
| Verificar **uma ou duas condições simples**        | `if` / `else`           |
| Verificar **várias possibilidades do mesmo valor** | `switch`                |
| Fazer **decisão rápida em uma linha**              | Operador ternário `? :` |

🚫 **Evite** `switch` para verificações com `<`, `>` ou `!==` → nesses casos use `if`.

***

### 🧬 Observação: Condições dentro de condições? Sim! Isso se chama **aninhamento**

Às vezes, uma decisão depende de **outra decisão anterior**.\
Nesse caso, usamos **estruturas condicionais aninhadas**, ou seja, um `if` **dentro de outro `if`**. 🪺

#### 🤔 Mas o que isso quer dizer?

É como perguntar:

> "Se o aluno passou, ele tirou nota boa ou só o suficiente?"

#### 🔍 Exemplo prático:

```javascript
let nota = 8;

if (nota >= 7) {
  console.log("Aprovado ✅");

  if (nota >= 9) {
    console.log("E com nota excelente! 🌟");
  }
} else {
  console.log("Reprovado ❌");
}
```

***

#### 🧠 Como o computador lê isso:

1. Verifica se `nota >= 7`
2. Se **for verdadeiro**, entra no primeiro `if`
3. Dentro dele, **verifica outra condição** (`nota >= 9`)
4. Se essa também for verdadeira, imprime a mensagem extra

***

#### ⚠️ Cuidado com a bagunça!

Muitos `if` dentro de `if` podem deixar seu código difícil de entender 😵‍💫\
Olha só este exemplo **não recomendado**:

```javascript
if (condicao1) {
  if (condicao2) {
    if (condicao3) {
      if (condicao4) {
        // 😨 Onde eu tô?
      }
    }
  }
}
```

#### ✅ Melhorar com lógica clara:

Use operadores lógicos `&&` e comentários para clarear a leitura:

```javascript
if (condicao1 && condicao2 && condicao3 && condicao4) {
  // Agora faz mais sentido 👌
}
```

💡 **Dica de programador esperto:**\
Sempre que você aninhar condições, **se pergunte se não daria pra simplificar** com operadores lógicos ou funções auxiliares.

***

### 💥 Erros comuns para evitar

1. ❌ **Esquecer o `break` no `switch`**\
   Isso faz o código "cair" no próximo `case`.

2. ❌ **Usar `=` no lugar de `==`**\
   `=` é para **atribuir**, `==` é para **comparar**.

```javascript
if (idade = 18) // errado! Isso muda o valor.
```

3. ❌ **Confundir `==` com `===`**\
   Sempre que possível, prefira `===`, pois compara **valor e tipo**.

4. ❌ **Colocar muita lógica em um ternário**\
   Fica difícil de ler! Use `if` para casos mais complexos.

***

### 🛠️ Boas práticas com exemplos reais

#### ✅ Bom exemplo: Código claro e direto

```javascript
let nota = 8;

if (nota >= 7) {
  console.log("Aprovado! 🎉");
} else {
  console.log("Reprovado! 😢");
}
```

#### ❌ Mau exemplo: Ternário confuso

```javascript
let status = nota > 9 ? "excelente" : nota > 6 ? "ok" : "ruim";
```

🧠 Parece legal, mas **fica difícil de entender!** Prefira usar `if` aqui.

***

### 💪 O poder das estruturas condicionais

Com elas, conseguimos:

* Criar sistemas de login 🔐
* Definir regras de jogos 🎮
* Controlar dispositivos inteligentes 🤖
* Personalizar páginas e apps de acordo com o usuário 🌐

**Elas são a base da lógica de qualquer sistema!**\
Dominar bem as estruturas condicionais é um superpoder no mundo da programação! 🦸‍♀️🦸‍♂️

***

### 🎲 Desafio!

Crie um programa que receba o **dia da semana** (ex: "segunda") e diga se é um **dia útil**, **fim de semana**, ou se é um **dia inválido**.

Dica: use `switch`, `case`, `default`, e evite letras maiúsculas com `.toLowerCase()`.
