Números e matemática

Em JavaScript, 0.1 + 0.2 dá 0.30000000000000004, e 17 % 5 dá 2. As duas coisas fazem sentido quando você sabe como os números são guardados e o que % quer dizer.

Os operadores aritméticos

Quase tudo o que os computadores fazem se resume a aritmética, e o JavaScript a escreve mais ou menos como você escreveria no papel. Os símbolos que fazem o trabalho se chamam operadores. Cinco você já conhece, e dois são novos:

Operador	Significado	Exemplo	Resultado
+	adição	7 + 2	9
-	subtração	7 - 2	5
*	multiplicação	7 * 2	14
/	divisão	7 / 2	3.5
%	resto	7 % 2	1
**	potência	7 ** 2	49

A multiplicação usa asterisco, porque a letra x seria confundida com uma variável chamada x. A divisão sempre dá a resposta exata, com decimais: 7 / 2 é 3.5, não 3. O operador de resto % divide e fica só com o que sobra. 17 % 5 é 2, porque 5 cabe três vezes em 17 (15) e sobram 2. Parece curiosidade, mas é um dos operadores mais usados em programação. Um número é par exatamente quando n % 2 é 0, e minutes % 60 dá os minutos que sobram depois de tirar as horas inteiras.

Ordem das operações

O JavaScript segue a mesma ordem da matemática da escola. Primeiro as potências, depois multiplicação, divisão e resto, depois adição e subtração. Operadores do mesmo nível são resolvidos da esquerda para a direita, exceto **, que vai da direita para a esquerda. Os parênteses passam na frente de tudo, então, na dúvida, ponha parênteses; eles não custam nada e deixam a intenção clara para o próximo leitor.

console.log(2 + 3 * 4);      // mostra 14
console.log((2 + 3) * 4);    // mostra 20
console.log(20 - 6 / 2);     // mostra 17
console.log(2 ** 3 * 5);     // mostra 40

Atalhos para atualizar uma variável

Atualizar uma variável com o próprio valor é tão comum que existem formas curtas. x += 5 quer dizer x = x + 5, e há as formas correspondentes -=, *= e /=. Somar ou tirar exatamente um tem uma forma ainda mais curta: x++ soma 1 e x-- subtrai 1. Você vai ver ++ o tempo todo em laços.

let coins = 10;
coins += 5;      // agora 15
coins *= 2;      // agora 30
coins--;         // agora 29
console.log(coins);   // mostra 29

As ferramentas do Math

O JavaScript vem com um objeto embutido chamado Math, que guarda ferramentas prontas para números. Math.round(2.5) arredonda para o inteiro mais próximo (3), Math.floor(2.9) sempre arredonda para baixo (2) e Math.ceil(2.1) sempre arredonda para cima (3). Math.max(4, 9, 2) dá o maior dos valores e Math.min o menor. Math.sqrt(81) é a raiz quadrada, 9, e Math.PI é o número π, cerca de 3.14159. Math.floor e % formam uma boa dupla: para 135 minutos, Math.floor(135 / 60) dá 2 horas e 135 % 60 dá 15 minutos.

Por que 0.1 + 0.2 não dá exatamente 0.3

O JavaScript guarda todo número em binário usando uma quantidade fixa de memória, seguindo o formato de precisão dupla IEEE 754 que o padrão ECMAScript especifica. Alguns decimais comuns, como 0.1, não podem ser escritos exatamente em binário, assim como 1/3 não pode ser escrito exatamente em decimal. Os pequenos erros de arredondamento costumam ficar escondidos, mas às vezes aparecem: 0.1 + 0.2 mostra 0.30000000000000004. Isso não é um bug no seu código. Quando você mostrar dinheiro ou medidas para pessoas, arredonde o resultado, por exemplo com (0.1 + 0.2).toFixed(2), que dá a string "0.30". Números inteiros até cerca de nove mil trilhões são guardados exatamente, então contagens nunca são afetadas.

Exemplos resolvidos

Exemplo 1. A média de 80, 90 e 85 é (80 + 90 + 85) / 3. Sem parênteses, 80 + 90 + 85 / 3 divide só o 85 e dá cerca de 198.3. Exemplo 2. 2024 é múltiplo de 4? 2024 % 4 é 0, então sim. Exemplo 3. Dividindo 50 balas entre 6 crianças: Math.floor(50 / 6) dá 8 para cada uma e 50 % 6 deixa 2 de sobra.

operador	Um símbolo que faz uma operação com valores: + - * / % **
%	Resto da divisão: 17 % 5 é 2
**	Potência: 2 ** 3 é 8
+=	x += 5 quer dizer x = x + 5
++	Somar exatamente 1 a uma variável
Math.floor	Arredondar para baixo até um inteiro
Math.round	Arredondar para o inteiro mais próximo
toFixed(2)	Formatar um número com 2 casas decimais, como string

O que isto mostra?
```
console.log(2 + 3 * 4);
```
O que isto mostra?
```
console.log((2 + 3) * 4);
```
O que isto mostra?
```
console.log(17 % 5);
```
O que isto mostra?
```
console.log(9 / 2);
```
O que isto mostra?
```
console.log(2 ** 5);
```

O que isto mostra?

let x = 10;
x += 4;
x *= 2;
console.log(x);

O que isto mostra?

let n = 5;
n++;
n++;
n--;
console.log(n);

O que isto mostra?

console.log(Math.floor(7.9), Math.ceil(7.1));

O que isto mostra?

console.log(Math.max(3, 11, 6) - Math.min(3, 11, 6));

O que isto mostra?
```
console.log(10 - 4 - 3);
```
Qual expressão é verdadeira para todo número par n?
- n % 2 === 0
- n / 2 === 0
- n % 2 === 1
O que isto mostra?
```
console.log((0.1 + 0.2).toFixed(2));
```

Pontos-chave

+ - * / funcionam como na matemática; / mantém os decimais.
% dá o resto; n % 2 === 0 quer dizer que n é par.
** é potência. Primeiro os parênteses, depois **, depois * / %, depois + -.
x += 5 e x++ são formas curtas de atualizar x.
Math.floor, Math.round, Math.ceil, Math.max, Math.min e Math.PI.
Decimais podem trazer pequenos erros de arredondamento; use toFixed para exibi-los.

Fontes deste curso (2)

MDN Web Docs, JavaScript Guide (developer.mozilla.org/en-US/docs/Web/JavaScript/Guide, chapters Introduction, Grammar and types, Control flow, Loops and iteration, Functions, Expressions and operators, Numbers and strings, Indexed collections, Working with objects; checked 2026-10-17)
Ecma International, ECMA-262 ECMAScript 2026 Language Specification, 17th edition, June 2026 (tc39.es/ecma262 and ecma-international.org/publications-and-standards/standards/ecma-262, checked 2026-10-17)

Data de verificação: 2026-10-17