Fundamentos de Operadores

Os fundamentos de operadores em programação são essenciais para realizar operações matemáticas, comparações lógicas, manipulação de dados e controle de fluxo dentro de um programa. Vamos aprender eles usando JavaScript?

Principais tipos de operadores em JavaScript:

1. Operadores Aritméticos

São usados para realizar operações matemáticas entre números. Esses operadores incluem:

• Adição (+): Soma dois valores.
• Subtração (-): Subtrai o segundo valor do primeiro.
• Multiplicação (*): Multiplica dois valores.
• Divisão (/): Divide o primeiro valor pelo segundo.
• Módulo (%): Retorna o resto da divisão entre dois valores.
• Exponenciação (``)**: Eleva o primeiro valor à potência do segundo.

Exemplo:

let a = 10;
let b = 3;

console.log(a + b);  // Adição: 13
console.log(a - b);  // Subtração: 7
console.log(a * b);  // Multiplicação: 30
console.log(a / b);  // Divisão: 3.333
console.log(a % b);  // Módulo: 1 (resto da divisão de 10 por 3)
console.log(a ** b); // Exponenciação: 1000 (10 elevado a 3)

2. Operadores de Atribuição

Os operadores de atribuição são usados para atribuir valores a variáveis. O operador mais comum é o "=", mas existem combinações com operadores aritméticos que facilitam o código.

• Atribuição (=): Atribui um valor à variável.
• Atribuição com adição (+=): Soma e atribui o resultado à variável.
• Atribuição com subtração (-=): Subtrai e atribui o resultado à variável.
• Atribuição com multiplicação (*=): Multiplica e atribui o resultado à variável.
• Atribuição com divisão (/=): Divide e atribui o resultado à variável.

Exemplo:

let x = 5;
x += 3;  // x = x + 3 -> 8
x -= 2;  // x = x - 2 -> 6
x *= 4;  // x = x * 4 -> 24
x /= 2;  // x = x / 2 -> 12

console.log(x);  // Resultado final: 12

3. Operadores de Comparação

Esses operadores comparam dois valores e retornam um valor booleano (true ou false). Eles são muito usados em estruturas de controle, como if, e while.

• Igualdade (==): Verifica se os valores são iguais, sem verificar o tipo.
• Identidade (===): Verifica se os valores e tipos são exatamente iguais.
• Diferente (!=): Verifica se os valores são diferentes.
• Diferença estrita (!==): Verifica se os valores e tipos são diferentes.
• Maior que (>): Verifica se o valor da esquerda é maior.
• Menor que (<): Verifica se o valor da esquerda é menor.
• Maior ou igual (>=): Verifica se o valor da esquerda é maior ou igual.
• Menor ou igual (<=): Verifica se o valor da esquerda é menor ou igual.

Exemplo:

let num1 = 10;
let num2 = '10';

console.log(num1 == num2);   // true (só compara o valor)
console.log(num1 === num2);  // false (compara valor e tipo)
console.log(num1 != num2);   // false (valores são iguais)
console.log(num1 !== num2);  // true (tipos são diferentes)
console.log(num1 > 5);       // true
console.log(num1 <= 10);     // true

4. Operadores Lógicos

Os operadores lógicos são usados para combinar expressões booleanas (verdadeiro ou falso) e são essenciais para controle de fluxo.

• AND ( && ): Retorna true se ambas as expressões forem verdadeiras.
• OR ( || ): Retorna true se ao menos uma das expressões for verdadeira.
• NOT ( ! ): Inverte o valor booleano de uma expressão.

Exemplo:

let a = true;
let b = false;

console.log(a && b);  // false (AND: ambos devem ser verdadeiros)
console.log(a || b);  // true (OR: ao menos um deve ser verdadeiro)
console.log(!a);      // false (NOT: inverte o valor de 'a')

5. Operadores Unários

Esses operadores trabalham com apenas um operando e podem modificar ou retornar o valor de uma variável.

• Incremento (++): Adiciona 1 ao valor da variável.
• Decremento (--): Subtrai 1 do valor da variável.

Exemplo:

let contador = 5;

contador++;  // Incrementa: contador = 6
console.log(contador);  // Saída: 6

contador--;  // Decrementa: contador = 5
console.log(contador);  // Saída: 5

É importante lembrar que a ordem desses operadores influenciam no comportamento da variável. Existem duas maneiras de usá-los:

• Prefixado ++x ou --x: Usa o valor atual da variável na expressão e depois faz o incremento/decremento.
• Posfixado x++ ou x--: Incrementa/decrementa o valor antes de usá-lo na expressão (como exemplificado anteriormente).

Saiba mais clicando aqui

6. Operadores Ternários

O operador ternário é uma forma simplificada de um if para atribuir valores com base em uma condição. Sua estrutura é condição ? valor_se_verdadeiro : valor_se_falso.

Exemplo:

let idade = 18;
let status = (idade >= 18) ? 'Maior de idade' : 'Menor de idade';

console.log(status);  // Saída: 'Maior de idade'

Saiba mais sobre Operadores Ternários aqui

7. Operador de Concatenar Strings (+)

O operador de adição (+) também pode ser usado para concatenar strings (unir textos).

Exemplo:

let primeiroNome = "Maria";
let segundoNome = "Silva";

let nomeCompleto = primeiroNome + " " + segundoNome;
console.log(nomeCompleto);  // Saída: "Maria Silva"

8. Operadores Bitwise (Bits a Bits)

Esses operadores realizam operações a nível de bits (0s e 1s), geralmente usados em programação de baixo nível, como operações de hardware. Não é comum usar esses tipos de operadores.

• AND Bit a Bit (&)
• OR Bit a Bit (|)
• XOR Bit a Bit (^)
• NOT Bit a Bit (~)
• Deslocamento à esquerda (<<)
• Deslocamento à direita (>>)

Exemplo:

let x = 5;  // Binário: 0101
let y = 3;  // Binário: 0011

console.log(x & y);  // AND Bit a Bit: 1 (0101 & 0011 -> 0001)
console.log(x | y);  // OR Bit a Bit: 7 (0101 | 0011 -> 0111)

Entender como os Operadores funcionam é fundamental para construir programas que realizem cálculos, comparações e controlam o fluxo do código de forma eficiente.