Operadores aritméticos: fazendo contas básicas

Em qualquer programa de computador, a capacidade de fazer cálculos é fundamental. Seja para somar preços, calcular médias, ou determinar posições em um jogo, os operadores aritméticos são suas ferramentas para realizar essas operações matemáticas básicas.

Pense neles como as funções de uma calculadora, mas que você controla com código.

Os operadores aritméticos básicos em JavaScript:

Operador	Nome	Exemplo	Resultado	Descrição
`+`	Adição	`5 + 3`	`8`	Soma dois números.
`-`	Subtração	`10 - 4`	`6`	Subtrai o segundo número do primeiro.
`*`	Multiplicação	`6 * 2`	`12`	Multiplica dois números.
`/`	Divisão	`15 / 3`	`5`	Divide o primeiro número pelo segundo.
`%`	Módulo (Resto)	`10 % 3`	`1`	Retorna o resto da divisão inteira.
`**`	Exponenciação	`2 ** 3`	`8`	Eleva o primeiro número à potência do segundo (2 elevado a 3).
`++`	Incremento	`let x = 5; x++;`	`x` agora é `6`	Adiciona 1 ao valor da variável.
`--`	Decremento	`let y = 5; y--;`	`y` agora é `4`	Subtrai 1 do valor da variável.

Exemplos práticos:

Vamos ver como usar esses operadores com variáveis.

let num1 = 20;
let num2 = 5;

// Adição
let resultadoAdicao = num1 + num2; // 20 + 5 = 25
console.log("Adição:", resultadoAdicao); // Saída: Adição: 25

// Subtração
let resultadoSubtracao = num1 - num2; // 20 - 5 = 15
console.log("Subtração:", resultadoSubtracao); // Saída: Subtração: 15

// Multiplicação
let resultadoMultiplicacao = num1 * num2; // 20 * 5 = 100
console.log("Multiplicação:", resultadoMultiplicacao); // Saída: Multiplicação: 100

// Divisão
let resultadoDivisao = num1 / num2; // 20 / 5 = 4
console.log("Divisão:", resultadoDivisao); // Saída: Divisão: 4

// Módulo (Resto da divisão)
let resultadoModulo = 22 % 5; // 22 dividido por 5 é 4 com resto 2
console.log("Módulo (22 % 5):", resultadoModulo); // Saída: Módulo (22 % 5): 2

// Exponenciação
let resultadoExponenciacao = 3 ** 4; // 3 elevado a 4 = 3 * 3 * 3 * 3 = 81
console.log("Exponenciação (3 ** 4):", resultadoExponenciacao); // Saída: Exponenciação (3 ** 4): 81

Incremento e Decremento (atalhos para adicionar/subtrair 1)

Os operadores ++ e -- são atalhos muito comuns para adicionar ou subtrair 1 de uma variável.

let contador = 0;
console.log("Contador inicial:", contador); // Saída: Contador inicial: 0

contador++; // É o mesmo que contador = contador + 1;
console.log("Contador depois do incremento:", contador); // Saída: Contador depois do incremento: 1

contador--; // É o mesmo que contador = contador - 1;
console.log("Contador depois do decremento:", contador); // Saída: Contador depois do decremento: 0

Pós-incremento/decremento vs. Pré-incremento/decremento (um detalhe importante!)

A posição do ++ ou -- importa quando você usa a variável em uma expressão ao mesmo tempo que a incrementa/decrementa.

Pós-incremento (x++): O valor original de x é usado na expressão, e depois x é incrementado.
Pré-incremento (++x): x é incrementado primeiro, e depois o novo valor de x é usado na expressão.

O mesmo vale para o decremento (x-- e --x).

let a = 5;
let b = a++; // 'b' recebe o valor original de 'a' (5), e 'a' é incrementado para 6.
console.log("a:", a); // Saída: a: 6
console.log("b:", b); // Saída: b: 5

let c = 5;
let d = ++c; // 'c' é incrementado para 6, e 'd' recebe o novo valor de 'c' (6).
console.log("c:", c); // Saída: c: 6
console.log("d:", d); // Saída: d: 6

Ordem de Operações (Precedência)

Assim como na matemática, os operadores aritméticos em JavaScript seguem uma ordem de precedência. Multiplicação e divisão são feitas antes de adição e subtração. Você pode usar parênteses () para forçar uma ordem diferente.

Lembre-se do PEMDAS/ParenExMulDivAddSub (Parênteses, Expoentes, Multiplicação e Divisão, Adição e Subtração).

let calculo1 = 10 + 5 * 2; // Primeiro 5 * 2 = 10, depois 10 + 10 = 20
console.log("Cálculo 1:", calculo1); // Saída: Cálculo 1: 20

let calculo2 = (10 + 5) * 2; // Primeiro (10 + 5) = 15, depois 15 * 2 = 30
console.log("Cálculo 2:", calculo2); // Saída: Cálculo 2: 30

Dominar os operadores aritméticos é essencial para qualquer tipo de lógica que envolva números. Eles são a base para cálculos mais complexos e para a manipulação de dados quantitativos em seus programas.