# 7.3 - Operadores

## 🧠 Operadores em JavaScript: a base para fazer o código pensar!

Em JavaScript, os **operadores** são como os "sinais" ou "ferramentas" que usamos para fazer o código **calcular, comparar, ou tomar decisões**. Eles ajudam o computador a **entender o que fazer com os valores** que você dá a ele.

Vamos conhecer os principais operadores de um jeito simples e direto! 👇

***

### ➕ Operadores Aritméticos

Esses são os operadores que usamos para **fazer contas**. Eles funcionam como em matemática!

| Operador | Significado            | Exemplo  | Resultado   |
| -------- | ---------------------- | -------- | ----------- |
| `+`      | Soma                   | `5 + 3`  | `8`         |
| `-`      | Subtração              | `10 - 4` | `6`         |
| `*`      | Multiplicação          | `2 * 3`  | `6`         |
| `/`      | Divisão                | `8 / 2`  | `4`         |
| `%`      | Resto da divisão       | `7 % 3`  | `1`         |
| `**`     | Exponenciação          | `2**3`   | `8`         |
| `++`     | Incrementa (soma 1)    | `x++`    | `x = x + 1` |
| `--`     | Decrementa (subtrai 1) | `x--`    | `x = x - 1` |

```js
let resultado = 10 % 3; 
console.log(resultado); // Mostra: 1
```

***

> 📌 **Observação importante sobre `++` e `--`**

Esses dois carinhas são chamados de **operadores de incremento (`++`) e decremento (`--`)**. Eles servem para **aumentar ou diminuir em 1** o valor de uma variável. Simples, né? 😄

Mas atenção: a **posição** deles muda o comportamento! 👀

:arrow\_forward: **Pós-incremento:**

```js
let x = 5;
console.log(x++); // Mostra: 5 (depois soma 1)
console.log(x);   // Agora x vale 6
```

:arrow\_backward: **Pré-incremento:**

```javascript
let y = 5;
console.log(++y); // Mostra: 6 (já soma 1 ANTES de mostrar)
```

***

### 🔁 Operadores de Atribuição

Eles são usados para **atribuir (ou atualizar) valores** a variáveis.

| Operador | Exemplo  | Igual a...    |
| -------- | -------- | ------------- |
| `=`      | `x = 5`  | Atribui 5 a x |
| `+=`     | `x += 2` | `x = x + 2`   |
| `-=`     | `x -= 3` | `x = x - 3`   |
| `*=`     | `x *= 4` | `x = x * 4`   |
| `/=`     | `x /= 2` | `x = x / 2`   |

```js
let pontos = 10;
pontos += 5;
console.log(pontos); // Mostra: 15
```

***

### 🤔 Operadores Relacionais (de Comparação)

Quer saber se algo é **igual**, **maior**, **menor** ou **diferente**? Esses são os operadores que usamos!

| Operador | Significado              | Exemplo     | Resultado |
| -------- | ------------------------ | ----------- | --------- |
| `==`     | Igual (valor)            | `5 == "5"`  | `true`    |
| `===`    | Igual (valor e tipo)     | `5 === "5"` | `false`   |
| `!=`     | Diferente (valor)        | `5 != "5"`  | `false`   |
| `!==`    | Diferente (valor e tipo) | `5 !== "5"` | `true`    |
| `>`      | Maior que                | `10 > 7`    | `true`    |
| `<`      | Menor que                | `2 < 3`     | `true`    |
| `>=`     | Maior ou igual           | `4 >= 4`    | `true`    |
| `<=`     | Menor ou igual           | `3 <= 2`    | `false`   |

```js
let idade = 18;
console.log(idade >= 18); // Mostra: true
```

***

### 🔌 Operadores Lógicos

São usados para **combinar condições**. Eles ajudam o código a tomar **decisões mais inteligentes**.

| Operador | Nome      | Exemplo           | Resultado |
| -------- | --------- | ----------------- | --------- |
| `&&`     | E (AND)   | `true && false`   | `false`   |
| `\|\|`   | OU (OR)   | `true \|\| false` | `true`    |
| `!`      | NÃO (NOT) | `!true`           | `false`   |

```js
let temDinheiro = true;
let temTempo = false;

if (temDinheiro && temTempo) {
  console.log("Vamos viajar! ✈️");
} else {
  console.log("Não vai rolar agora 😢");
}
```

***

### 🧪 Operador Ternário

Quer uma forma rápida de decidir algo com base em uma condição? Use o **ternário**!

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

Exemplo:

```js
let idade = 20;
let podeBeber = idade >= 18 ? "Sim 🍻" : "Não 🚫";
console.log(podeBeber); // Mostra: Sim 🍻
```

***

### 📌 Aprofundando um Pouquinho...

#### 🧪 `==` vs `===` — Qual a diferença real?

* `==` **compara só o valor**, mesmo se os tipos forem diferentes. Pode causar bugs se não tomar cuidado!
* `===` **compara valor e tipo**. É o mais recomendado!

```javascript
5 == '5'  // true
5 === '5' // false
```

📌 Dica de pro: use sempre `===` e `!==` para evitar confusão! 😉

***

#### 🧠 Curiosidade: o que é "falsy" e "truthy"?

No JavaScript, algumas coisas são consideradas **falsas** mesmo sem serem o `false` literal.

🔴 Falsy values: `false`, `0`, `""` (string vazia), `null`, `undefined`, `NaN`

✅ Tudo o resto é "truthy" (verdadeiro).

```javascript
if ("") {
  console.log("Isso aparece?");
} else {
  console.log("String vazia é falsy!")
```

***

### ⚡ Dica Final

Os operadores são uma parte **fundamental** de qualquer linguagem de programação. Com eles, você pode:

✅ Fazer contas\
✅ Comparar valores\
✅ Tomar decisões\
✅ Escrever códigos mais inteligentes e eficientes

Continue explorando, testando e praticando! 🚀\
O JavaScript tem muito a te oferecer, e você tem muito poder nas mãos com ele! 💪✨