Dando Poder de Decisão aos Programas
Até este momento, você aprendeu a armazenar informações em variáveis, trabalhar com diferentes tipos de dados e realizar operações matemáticas. Mas como um programa pode tomar decisões? Como ele sabe se um usuário tem idade suficiente para acessar determinado conteúdo? Como verifica se uma senha está correta? Como determina se deve executar uma ação ou outra?
A resposta está nos operadores de comparação e lógicos - ferramentas que permitem ao código "pensar" e tomar decisões baseadas em condições. Estes operadores são a ponte entre os dados que manipulamos e a lógica que dá vida aos nossos programas.
Nesta aula, você compreenderá como comparar valores, combinar múltiplas condições e construir a base para criar programas verdadeiramente inteligentes e interativos.
O Conceito Fundamental
Imagine que você está em uma loja e precisa decidir se vai comprar um produto. Você compara o preço com o dinheiro que tem disponível. Se o preço for menor ou igual ao seu dinheiro, você pode comprar. Se for maior, não pode.
Na programação, fazemos exatamente isso - comparamos valores para tomar decisões. Os operadores de comparação são ferramentas que comparam dois valores e retornam um resultado booleano: true (verdadeiro) ou false (falso).
let preco = 50;
let dinheiro = 100;
console.log(preco <= dinheiro); // true - posso comprar!
Os Operadores Relacionais
JavaScript oferece seis operadores principais para comparar valores:
1. Maior que (>)
Verifica se o valor da esquerda é maior que o da direita:
console.log(10 > 5); // true
console.log(3 > 8); // false
console.log(5 > 5); // false (não é maior, é igual)
2. Menor que (<)
Verifica se o valor da esquerda é menor que o da direita:
console.log(3 < 8); // true
console.log(10 < 5); // false
console.log(5 < 5); // false (não é menor, é igual)
3. Maior ou igual a (>=)
Verifica se o valor da esquerda é maior OU igual ao da direita:
console.log(10 >= 5); // true (10 é maior que 5)
console.log(5 >= 5); // true (5 é igual a 5)
console.log(3 >= 8); // false
4. Menor ou igual a (<=)
Verifica se o valor da esquerda é menor OU igual ao da direita:
console.log(3 <= 8); // true (3 é menor que 8)
console.log(5 <= 5); // true (5 é igual a 5)
console.log(10 <= 5); // false
Exemplo Prático: Sistema de Idade
let idadeUsuario = 16;
let idadeMinima = 18;
console.log(idadeUsuario >= idadeMinima); // false
// O usuário NÃO tem idade suficiente
idadeUsuario = 20;
console.log(idadeUsuario >= idadeMinima); // true
// Agora o usuário tem idade suficiente
Comparando Strings
JavaScript pode comparar textos usando a ordem "lexicográfica" (ordem do dicionário):
console.log("A" < "Z"); // true
console.log("gato" < "zebra"); // true
console.log("maçã" < "banana"); // false (m vem depois de b)
Importante: Letras maiúsculas são consideradas "menores" que minúsculas:
console.log("A" < "a"); // true
console.log("Z" < "a"); // true
Exemplo Prático: Ordenação Alfabética
let nome1 = "Ana";
let nome2 = "Bruno";
console.log(nome1 < nome2); // true - Ana vem antes de Bruno
Os Operadores de Igualdade
Aqui está um dos conceitos mais importantes e que mais confunde iniciantes: JavaScript tem DOIS tipos de igualdade!
Igualdade Simples (==)
O operador == compara valores fazendo conversões automáticas de tipo quando necessário:
console.log(5 == "5"); // true (converte string para número)
console.log(1 == true); // true (converte boolean para número)
console.log(0 == false); // true (converte boolean para número)
console.log("" == false); // true (ambos viram 0)
Por que isso acontece? JavaScript tenta "ajudar" convertendo os valores para que possam ser comparados. Mas isso pode causar surpresas!
Igualdade Estrita (===)
O operador === compara valores SEM fazer conversões. Para ser true, os valores devem ser idênticos em valor E tipo:
console.log(5 === "5"); // false (número diferente de string)
console.log(1 === true); // false (número diferente de boolean)
console.log(0 === false); // false (número diferente de boolean)
console.log(5 === 5); // true (mesmo valor e mesmo tipo)
Desigualdade (!= e !==)
Funcionam de forma oposta aos operadores de igualdade:
// Desigualdade simples (com conversão)
console.log(5 != "5"); // false
console.log(5 != 6); // true
// Desigualdade estrita (sem conversão)
console.log(5 !== "5"); // true (tipos diferentes)
console.log(5 !== 5); // false (idênticos)
⚠️ Regra de Ouro: Use === e !==
Recomendação: Sempre prefira os operadores estritos (=== e !==) para evitar comportamentos inesperados:
// ❌ Evite
if (idade == "18") {
console.log("Maior de idade");
}
// ✅ Prefira
if (idade === 18) {
console.log("Maior de idade");
}
Casos Especiais: null e undefined
Estes valores têm comportamentos únicos em comparações:
Com Igualdade
console.log(null == undefined); // true (caso especial!)
console.log(null === undefined); // false (tipos diferentes)
console.log(null == 0); // false
console.log(undefined == 0); // false
Com Operadores Relacionais
console.log(null > 0); // false
console.log(null == 0); // false
console.log(null >= 0); // true (!!) - null vira 0 na comparação
console.log(undefined > 0); // false (undefined vira NaN)
console.log(undefined < 0); // false (undefined vira NaN)
console.log(undefined == 0); // false
Lição: Tenha cuidado especial ao comparar null e undefined!
O Valor Especial: NaN
NaN ("Not a Number") tem uma característica única - ele NÃO é igual a nada, nem a si mesmo:
console.log(NaN == NaN); // false (!!)
console.log(NaN === NaN); // false (!!)
// Para verificar se algo é NaN, use:
console.log(isNaN(NaN)); // true
console.log(isNaN("texto")); // true
console.log(Number.isNaN(NaN)); // true
Próximos passos
Na próxima aula você aprenderá sobre como usar operadores lógicos:
- Tipos de operadores lógicos: AND, OR e NOT
- Como combinar múltiplas condições
- Avaliação curta (short-circuiting)
- Precedencia de operadores
Quanto mais você praticar, mais natural se tornará o processo de criar lógicas complexas!