Aqui está a tradução do artigo de teoria de programação do Russo para o Português, seguindo todas as regras estabelecidas.

O que é isso e para que serve?

Imagine que você é um robô que executa comandos. Para tomar decisões, você precisa saber comparar coisas e verificar condições. Por exemplo:

• Comparação: "Você tem 100 reais?" (você compara seu dinheiro com o número 100).
• Lógica: "Você tem 100 reais E não está com fome?" (você verifica duas condições ao mesmo tempo).

Em JavaScript, os operadores de comparação e os operadores lógicos ajudam o computador a responder a essas perguntas. O resultado será sempre true (verdadeiro) ou false (falso). É como um semáforo: verde — pode ir (true), vermelho — pare (false).

Para que serve isso? Sem eles, os programas seriam entediantes — eles apenas executariam comandos em ordem. Mas com eles, o programa pode reagir a diferentes situações: por exemplo, se o usuário digitou a senha correta — deixá-lo entrar, se não — mostrar um erro.

Em Python, esses operadores funcionam quase da mesma forma, mas em JavaScript há suas peculiaridades. Vamos analisá-los.

Exemplos de código com explicação

1. Operadores básicos de comparação: >, <, >=, <=

Os mais simples — como na aula de matemática. Comparamos números:

// Exemplo 1: Maior ou menor?
let idade = 12;
let podeEntrar = idade >= 12; // Pode entrar se a idade for 12 ou mais?
console.log(podeEntrar); // Exibe: true (porque 12 >= 12 — verdadeiro)

// Exemplo 2: Comparação com um limite
let temperatura = 30;
let estaQuente = temperatura > 25;   // Maior que 25?
console.log(estaQuente); // true (30 > 25 — verdadeiro)

let estaFrio = temperatura < 10; // Menor que 10?
console.log(estaFrio); // false (30 não é menor que 10)

// Exemplo 3: Strings também podem ser comparadas!
console.log("abacaxi" > "banana"); // false
// Por quê? As letras são comparadas em ordem alfabética: 'a' (1ª letra) é menor que 'b' (2ª letra)
// Em Python é a mesma coisa, mas a sensibilidade a maiúsculas/minúsculas é diferente

Importante: Em JavaScript, as strings são comparadas pelo código Unicode (como em uma tabela). "a" é menor que "z", e "A" é menor que "a". É como um dicionário: primeiro vêm as letras maiúsculas, depois as minúsculas.

2. Operadores de igualdade: == e ===

Aqui começa a parte mais interessante! Em JavaScript, existem duas maneiras de verificar se os valores são iguais:

• == — "igualdade não estrita" (compara os valores, mas pode converter os tipos)
• === — "igualdade estrita" (compara o valor e o tipo de dado)

// Exemplo 4: Comparação de números e strings
let numero = 5;
let string = "5";

console.log(numero == string);   // true — porque 5 é igual a 5 (JavaScript converteu a string em número)
console.log(numero === string);  // false — porque número (number) não é igual a string (string)!

// Em Python isso não existe: "5" == 5 resulta em False imediatamente, sem conversão

// Exemplo 5: Comparação com true/false
console.log(1 == true);  // true — porque true é convertido para 1
console.log(1 === true); // false — tipos diferentes (número vs boolean)

console.log(0 == false); // true
console.log(0 === false); // false

// Exemplo 6: Valores vazios
console.log(null == undefined); // true — regra especial do JS
console.log(null === undefined); // false — tipos diferentes

// Em Python não existe undefined, existe apenas None, e ele não é igual a nada, exceto a si mesmo

Dica para iniciantes: Use sempre === (igualdade estrita) para evitar surpresas. É como na matemática: 5 e "5" são coisas diferentes, mesmo que pareçam semelhantes.

3. Operador lógico && (E)

O operador "E" (AND) retorna true apenas se ambas as condições forem verdadeiras. Na vida real é como: "Vou passear se fizer a lição de casa E minha mãe permitir".

// Exemplo 7: Verificando duas condições
let idade = 14;
let temIngresso = true;

let podeIr_ao_cinema = (idade >= 12) && (temIngresso === true);
console.log(podeIr_ao_cinema); // true — a idade é adequada E tem ingresso

// Se a idade fosse 10:
idade = 10;
podeIr_ao_cinema = (idade >= 12) && (temIngresso === true);
console.log(podeIr_ao_cinema); // false — a primeira condição é falsa, a segunda é verdadeira, mas o E exige ambas

// Exemplo 8: Condição complexa
let nota = 4;
let comportamento = "otimo";

let seraElogiado = (nota === 5) && (comportamento === "otimo");
console.log(seraElogiado); // false — a nota não é 5, embora o comportamento seja ótimo

// Em Python é escrito da mesma forma: and

Dica útil: JavaScript é "preguiçoso" — se a primeira condição em && for falsa, ele nem verifica a segunda. Isso é chamado de "curto-circuito". Economizamos tempo!

4. Operador lógico || (OU)

O operador "OU" (OR) retorna true se pelo menos uma condição for verdadeira. Como na vida: "Vou passear se fizer a lição de casa OU se estiver sol lá fora".

// Exemplo 9: Escolha entre duas opções
let temDinheiro = false;
let temPresente = true;

let podeComprarJogo = temDinheiro || temPresente;
console.log(podeComprarJogo); // true — não tem dinheiro, mas tem presente (uma condição é verdadeira)

// Exemplo 10: Verificação de idade
let idadeUsuario = 17;
let entradaPermitida = (idadeUsuario >= 18) || (idadeUsuario >= 16 && temIngresso);
// Se idade >=18 OU (idade >=16 E tem ingresso)
console.log(entradaPermitida); // false — 17 não é >=18, e embora 17>=16, temIngresso não foi definido (undefined — que é false)

// Exemplo 11: Valores padrão
let nome = "";
let nomeExibido = nome || "Convidado";
console.log(nomeExibido); // "Convidado" — porque uma string vazia é considerada false

// Em Python: nome or "Convidado" — funciona da mesma forma

Detalhe: || também é "preguiçoso" — se a primeira condição for verdadeira, a segunda não é verificada. Isso é usado para definir valores padrão.

5.