Operações Aritméticas em JavaScript

Para executar diferentes ações com valores (por exemplo, adição, subtração etc.), a linguagem JavaScript oferece operações. As operações podem receber um, dois ou três operandos e aplicar algumas ações a eles. Dependendo do tipo de operação, podem ser usados literais (números, strings), variáveis e constantes ou os resultados de outras operações.

Vamos considerar quais operações aritméticas podemos usar em JavaScript.

JavaScript suporta todas as operações matemáticas básicas:

Adição

const x = 50 + 10;
console.log(x); // 60

Subtração

const x = 50 - 10;
console.log(x); // 40

Multiplicação

const x = 50 * 10;
console.log(x); // 500

Divisão

const x = 50 / 10;
console.log(x); // 5

A divisão por módulo (operador %)

const x = 5 % 2;
console.log(x); // 1

A divisão por módulo retorna o resto da divisão de um número pelo outro. Por exemplo, 5 % 2 = 1, porque 2 cabe em 5 duas vezes, com um resto de 1.

Exponenciação

O operador ** eleva um número a uma potência específica:

número ** potência;

Por exemplo:

const n = 2 ** 3;
console.log(n); // 8

const x = 3;
const y = 2;
const z = x ** y;
console.log(z); // 9

Incremento:

let x = 5;
x++; // x = 6

O operador de incremento ++ aumenta o valor da variável em uma unidade. Existe o incremento prefixado, que primeiro aumenta a variável em uma unidade e então retorna seu valor. E há o incremento pós-fixado, que primeiro retorna o valor da variável que tinha antes de ser aumentado em uma unidade:

// incremento prefixado
let x = 5;
let z = ++x;
console.log(x); // 6
console.log(z); // 6

// incremento pós-fixado
let a = 5;
let b = a++;
console.log(a); // 6
console.log(b); // 5

O incremento é equivalente à operação:

a = a + 1;

Decremento diminui o valor da variável em uma unidade. Também existem decremento prefixado e pós-fixados:

// decremento prefixado
let x = 5;
let z = --x;
console.log(x); // 4
console.log(z); // 4

// decremento pós-fixado
let a = 5;
let b = a--;
console.log(a); // 4
console.log(b); // 5

Assim como na matemática, todas as operações são realizadas da esquerda para a direita e diferem em prioridade: primeiro as operações de incremento e decremento, depois são realizadas a multiplicação e a divisão, e por fim a adição e a subtração. Para alterar a ordem padrão de execução das operações, parte das expressões pode ser colocada entre parênteses:

let x = 10;
let y = 5 + (6 - 2) * --x;
console.log(y); // 41

Operações Aritméticas com Atribuição

No JavaScript, também existem várias operações que combinam operações aritméticas com atribuição:

+= Adição seguida da atribuição do resultado. Por exemplo:
```
let a = 23;
a += 5; //  a = a + 5
console.log(a); // 28
```
-= Subtração seguida da atribuição do resultado:
```
let a = 23;
a -= 5; //  a = a - 5
console.log(a); // 18
```
*= Multiplicação seguida da atribuição do resultado:
```
let a = 23;
a *= 5; //  a = a * 5
console.log(a); // 115
```
/= Divisão seguida da atribuição do resultado:
```
let a = 23;
a /= 5; //  a = a / 5
console.log(a); // 4.6
```

%= Divisão por módulo seguida da atribuição do resultado:

let x = 10;
x %= 3; // equivalente a x = x % 3
console.log(x); // 1, pois 10 - 3*3 = 1

**= Exponenciação seguida da atribuição do resultado:
```
let x = 5;
x **= 3; // x = x ** 3
console.log(x); // 125
```