Explicação de Operadores em Programação

Operadores são símbolos que instruem o compilador ou interpretador a executar operações matemáticas, relacionais ou lógicas específicas e produzir um resultado. Eles são pilares fundamentais de qualquer linguagem de programação.

Operadores de Atribuição

Os operadores de atribuição são utilizados para atribuir um valor a uma variável. O operador de atribuição mais comum é o sinal de igual (=).

• =: Atribui o valor do operando da direita ao operando da esquerda.
  Ex: let x = 10;
• +=: Atribuição de adição. Adiciona o valor do operando da direita ao operando da esquerda e atribui o resultado ao operando da esquerda.
  Ex: x += 5; (equivalente a x = x + 5;)
• -=: Atribuição de subtração.
  Ex: x -= 3; (equivalente a x = x - 3;)
• *=: Atribuição de multiplicação.
  Ex: x *= 2; (equivalente a x = x * 2;)
• /=: Atribuição de divisão.
  Ex: x /= 4; (equivalente a x = x / 4;)
• %=: Atribuição de módulo (resto da divisão).
  Ex: x %= 5; (equivalente a x = x % 5;)
• **=: Atribuição de exponenciação (potência).
  Ex: x **= 2; (equivalente a x = x ** 2;)

Exemplo de Operadores de Atribuição (JavaScript):

let x = 10;
console.log("x inicial:", x); // Saída: 10

x += 5; // x = 10 + 5
console.log("x depois de x += 5:", x); // Saída: 15

x -= 3; // x = 15 - 3
console.log("x depois de x -= 3:", x); // Saída: 12

x *= 2; // x = 12 * 2
console.log("x depois de x *= 2:", x); // Saída: 24

x /= 4; // x = 24 / 4
console.log("x depois de x /= 4:", x); // Saída: 6

x %= 5; // x = 6 % 5 (resto de 6 por 5 é 1)
console.log("x depois de x %= 5:", x); // Saída: 1

x = 2;
x **= 3; // x = 2 ** 3 (2 elevado a 3)
console.log("x depois de x **= 3:", x); // Saída: 8

Operadores Aritméticos

Os operadores aritméticos são usados para realizar operações matemáticas comuns como adição, subtração, multiplicação e divisão.

• +: Adição.
  Ex: a + b
• -: Subtração.
  Ex: a - b
• *: Multiplicação.
  Ex: a * b
• /: Divisão.
  Ex: a / b
• %: Módulo (resto da divisão). Retorna o resto da divisão entre dois números.
  Ex: a % b
• **: Exponenciação (potência). Calcula a base elevada ao expoente.
  Ex: a ** b (a elevado a b)
• ++: Incremento. Aumenta o valor de uma variável em 1.
  Ex: x++; ou ++x;
• --: Decremento. Diminui o valor de uma variável em 1.
  Ex: x--; ou --x;

Exemplo de Operadores Aritméticos (JavaScript):

let num1 = 10;
let num2 = 3;

let soma = num1 + num2;
console.log("Soma:", soma); // Saída: 13

let subtracao = num1 - num2;
console.log("Subtração:", subtracao); // Saída: 7

let multiplicacao = num1 * num2;
console.log("Multiplicação:", multiplicacao); // Saída: 30

let divisao = num1 / num2;
console.log("Divisão:", divisao); // Saída: 3.333...

let modulo = num1 % num2;
console.log("Módulo:", modulo); // Saída: 1 (resto de 10 dividido por 3)

let potenciacao = num1 ** num2;
console.log("Potenciação:", potenciacao); // Saída: 1000 (10 elevado a 3)

let contador = 5;
contador++;
console.log("Incremento:", contador); // Saída: 6

contador--;
console.log("Decremento:", contador); // Saída: 5

Operadores Lógicos

Os operadores lógicos são usados para combinar expressões condicionais e retornar um valor booleano (true ou false). Eles são essenciais para o controle de fluxo em programas.

• && (AND lógico): Retorna true se todos os operandos forem verdadeiros. Se um for falso, o resultado é falso.
  Ex: (idade >= 18 && temCnh)
• || (OR lógico): Retorna true se pelo menos um dos operandos for verdadeiro. Somente retorna falso se todos forem falsos.
  Ex: (temDinheiro || temCartao)
• ! (NOT lógico): Inverte o valor booleano do operando. Se for true, torna-se false; se for false, torna-se true.
  Ex: !podeEntrar (se podeEntrar for true, !podeEntrar será false)

Exemplo de Operadores Lógicos (JavaScript):

let idade = 20;
let temCnh = true;
let temCarro = false;

// Operador AND (&&)
let podeDirigir = (idade >= 18 && temCnh);
console.log("Pode dirigir (idade >= 18 E tem CNH)?", podeDirigir); // Saída: true (true && true -> true)

let acessoTotal = (idade > 21 && temCnh && temCarro);
console.log("Acesso total (idade > 21 E tem CNH E tem Carro)?", acessoTotal); // Saída: false (false && true && false -> false)

// Operador OR (||)
let podeComprar = (idade >= 18 || temCarro);
console.log("Pode comprar algo (idade >= 18 OU tem Carro)?", podeComprar); // Saída: true (true || false -> true)

let podeSair = (idade > 25 || temCnh);
console.log("Pode sair (idade > 25 OU tem CNH)?", podeSair); // Saída: true (false || true -> true)

// Operador NOT (!)
let naoTemCnh = !temCnh;
console.log("Não tem CNH?", naoTemCnh); // Saída: false (!true -> false)

let naoTemCarro = !temCarro;
console.log("Não tem Carro?", naoTemCarro); // Saída: true (!false -> true)