Resto da Divisão (Módulo)

O operador módulo (%) retorna o resto da divisão inteira entre dois números. É o valor que “sobra” após dividir o dividendo pelo divisor o máximo de vezes possível com números inteiros.

Sintaxe

dividendo % divisor

Parâmetros

dividendo: O número a ser dividido (operando esquerdo).
divisor: O número pelo qual dividir (operando direito).

Valor de Retorno

O resto da divisão inteira de dividendo por divisor.

Descrição

A operação módulo encontra o resto que sobra após realizar a divisão inteira.

Por exemplo, quando dividimos 10 por 3, obtemos 3 como quociente (pois 3 × 3 = 9) e 1 como resto (pois 10 - 9 = 1). Portanto, 10 % 3 retorna 1.

Fórmula da divisão inteira: dividendo / divisor = quociente + (resto / divisor)

Fórmula para confirmar o resultado: (quociente * divisor) + resto = dividendo

Características importantes:

O sinal do resultado tem o mesmo sinal do dividendo
Se o divisor for 0, o resultado é NaN
Funciona com números de ponto flutuante, não apenas inteiros

Exemplos Básicos

Divisões Simples

// Exemplo fundamental: 10 ÷ 3
% 3;              // 1 (10 = 3 × 3 + 1, resto = 1)

// Outros exemplos
% 5;              // 2 (17 = 5 × 3 + 2, resto = 2)
% 4;              // 0 (20 = 4 × 5 + 0, divisão exata)
% 2;               // 1 (7 = 2 × 3 + 1, resto = 1)
% 4;              // 3 (15 = 4 × 3 + 3, resto = 3)

Quando o Dividendo é Menor que o Divisor

Se o dividendo é menor que o divisor, o resto é o próprio dividendo.

% 10;              // 3 (não dá para dividir 3 por 10, resto = 3)
% 8;               // 5 (não dá para dividir 5 por 8, resto = 5)
% 100;             // 1 (não dá para dividir 1 por 100, resto = 1)

Números Negativos

O sinal do resultado segue o sinal do dividendo.

// Dividendo negativo
-10 % 3;             // -1 (-10 = 3 × -3 + (-1))
-17 % 5;             // -2 (-17 = 5 × -3 + (-2))

// Divisor negativo
10 % -3;             // 1 (o sinal segue o dividendo)
17 % -5;             // 2

// Ambos negativos
-10 % -3;            // -1 (sinal do dividendo prevalece)

Números Decimais

O operador módulo também funciona com números de ponto flutuante.

5 % 2;             // 1.5 (5.5 = 2 × 2 + 1.5)
8 % 2.5;           // 0.3 (7.8 = 2.5 × 3 + 0.3, aproximadamente)
5 % 3;            // 1.5 (10.5 = 3 × 3 + 1.5)

Aplicações Práticas

1. Verificar Paridade (Par ou Ímpar)

Para determinar se um número é par ou ímpar, calcule o resto da divisão por 2.

Regra: - Se numero % 2 === 0, o número é par - Se numero % 2 === 1 (ou !== 0), o número é ímpar

// Números pares (resto 0)
4 % 2;               // 0 → par
10 % 2;              // 0 → par
100 % 2;             // 0 → par
0 % 2;               // 0 → par (zero é par)

// Números ímpares (resto 1)
3 % 2;               // 1 → ímpar
7 % 2;               // 1 → ímpar
99 % 2;              // 1 → ímpar

// Verificação prática
numero = 42;
numero % 2 === 0;    // true (42 é par)

numero = 37;
numero % 2 === 0;    // false (37 é ímpar)

2. Identificar Múltiplos

Se o resto da divisão é 0, o dividendo é múltiplo do divisor.

Regra: Se a % b === 0, então a é múltiplo de b

// Múltiplos de 3
9 % 3;               // 0 → 9 é múltiplo de 3
12 % 3;              // 0 → 12 é múltiplo de 3
15 % 3;              // 0 → 15 é múltiplo de 3
10 % 3;              // 1 → 10 NÃO é múltiplo de 3

// Múltiplos de 5
25 % 5;              // 0 → 25 é múltiplo de 5
50 % 5;              // 0 → 50 é múltiplo de 5
37 % 5;              // 2 → 37 NÃO é múltiplo de 5

// Verificação prática: número divisível por 4?
numero = 20;
numero % 4 === 0;    // true (20 é divisível por 4)

numero = 22;
numero % 4 === 0;    // false (22 não é divisível por 4)

3. Operações Cíclicas (Circuito de Relógio)

O módulo é perfeito para operações que se repetem em ciclos, como relógios, calendários e rotações.

// Formato 12 horas: converter hora militar para AM/PM
hora24 = 15;         // 15:00 (3 PM)
hora12 = hora24 % 12;
// 3 (15 % 12 = 3)

hora24 = 21;         // 21:00 (9 PM)
hora12 = hora24 % 12;
// 9 (21 % 12 = 9)

// Dias da semana (0-6): descobrir que dia será daqui a N dias
diaAtual = 3;        // quarta-feira (0=domingo, 3=quarta)
diasFuturos = 10;
diaFuturo = (diaAtual + diasFuturos) % 7;
// 6 (sábado: (3 + 10) % 7 = 13 % 7 = 6)

// Rotação circular em array (navegar em loop infinito)
indiceAtual = 7;
tamanhoArray = 5;
proximoIndice = (indiceAtual + 1) % tamanhoArray;
// 3 (8 % 5 = 3, volta ao início do array)

4. Converter Unidades de Tempo

Dividir um total de tempo em horas, minutos e segundos.

// Converter segundos totais em formato HH:MM:SS
totalSegundos = 3665;

// Calcular horas (divisão inteira por 3600)
horas = Math.floor(totalSegundos / 3600);
// 1 hora (3665 / 3600 = 1.018...)

// Calcular minutos (resto da divisão por 3600, depois dividir por 60)
restoAposHoras = totalSegundos % 3600;
// 65 segundos (3665 % 3600 = 65)
minutos = Math.floor(restoAposHoras / 60);
// 1 minuto (65 / 60 = 1.08...)

// Calcular segundos (resto da divisão por 60)
segundos = restoAposHoras % 60;
// 5 segundos (65 % 60 = 5)

// Resultado: 3665 segundos = 1h 1m 5s

5. Alternar Entre Valores (Toggle)

Alternar entre dois estados usando módulo.

// Alternar entre 0 e 1
estado = 0;
estado = (estado + 1) % 2;
// 1 (próximo estado)
estado = (estado + 1) % 2;
// 0 (volta ao primeiro estado)

// Alternar entre 3 cores em sequência
corAtual = 0;        // 0=vermelho, 1=verde, 2=azul
corAtual = (corAtual + 1) % 3;
// 1 (verde)
corAtual = (corAtual + 1) % 3;
// 2 (azul)
corAtual = (corAtual + 1) % 3;
// 0 (vermelho, volta ao início)

6. Distribuição em Grupos

Distribuir itens em grupos ou colunas de forma uniforme.

// Distribuir itens em 3 colunas
totalItens = 10;
numeroColunas = 3;

// Item 0: qual coluna?
item0 = 0 % 3;       // 0 (coluna 0)
item1 = 1 % 3;       // 1 (coluna 1)
item2 = 2 % 3;       // 2 (coluna 2)
item3 = 3 % 3;       // 0 (volta para coluna 0)
item4 = 4 % 3;       // 1 (coluna 1)
// ... padrão se repete

// Criar layout tipo "zebra" (linhas alternadas)
linha = 7;
linha % 2 === 0;     // false (linha ímpar)

linha = 8;
linha % 2 === 0;     // true (linha par)

7. Limitar Valores a um Intervalo

Manter um valor dentro de um intervalo cíclico.

// Limitar ângulo a 360 graus (0-359)
angulo = 450;
anguloNormalizado = angulo % 360;
// 90 graus (450 % 360 = 90)

angulo = 720;
anguloNormalizado = angulo % 360;
// 0 graus (uma volta completa)

// Limitar índice a tamanho de array
indice = 15;
tamanho = 10;
indiceValido = indice % tamanho;
// 5 (15 % 10 = 5, dentro do range 0-9)

8. Gerar Padrões Repetitivos

Criar sequências que se repetem a cada N elementos.

// Padrão que se repete a cada 4 elementos
// Útil para aplicar classes CSS alternadas, etc.
posicao = 0;
posicao % 4;         // 0 (primeiro do padrão)

posicao = 1;
posicao % 4;         // 1

posicao = 4;
posicao % 4;         // 0 (reinicia o padrão)

posicao = 7;
posicao % 4;         // 3

posicao = 8;
posicao % 4;         // 0 (reinicia novamente)

9. Validar Números de Identificação

Algoritmos de validação como CPF, CNPJ, ISBN usam operações módulo.

// Exemplo simplificado: verificar dígito verificador
// usando módulo 11 (comum em documentos brasileiros)
soma = 150;
resto = soma % 11;
// 7 (resto da divisão por 11)

// Calcular dígito verificador
digitoVerificador = resto < 2 ? 0 : 11 - resto;
// 4 (11 - 7 = 4)

10. Matemática Modular

Operações em aritmética modular, usada em criptografia e ciência da computação.

// Adição modular (mod 12, como relógio)
a = 8;
b = 7;
(a + b) % 12;        // 3 (15 % 12 = 3)

// Multiplicação modular
a = 5;
b = 6;
(a * b) % 7;         // 2 (30 % 7 = 2)

// Potência modular (útil em criptografia)
base = 3;
expoente = 4;
modulo = 5;
Math.pow(base, expoente) % modulo;
// 1 (81 % 5 = 1)

Casos Especiais

// Divisão por zero
10 % 0;              // NaN (não é possível dividir por zero)

// Zero como dividendo
0 % 5;               // 0 (zero dividido por qualquer número é zero)

// Números iguais
5 % 5;               // 0 (divisão exata)

// Infinity
Infinity % 5;        // NaN
5 % Infinity;        // 5

// NaN
NaN % 5;             // NaN
5 % NaN;             // NaN

Diferença entre Módulo e Resto

Em JavaScript, o operador % é tecnicamente o operador de resto, não módulo matemático puro, pois o resultado mantém o sinal do dividendo.

// Resto (JavaScript %)
-10 % 3;             // -1 (sinal do dividendo)

// Módulo matemático verdadeiro seria:
// -10 mod 3 = 2

// Para obter módulo matemático em JavaScript:
dividendo = -10;
divisor = 3;
((dividendo % divisor) + divisor) % divisor;
// 2 (módulo matemático correto)

Tabela de Referência Rápida

Expressão	Resultado	Interpretação
`10 % 3`	`1`	10 = 3 × 3 + 1
`15 % 4`	`3`	15 = 4 × 3 + 3
`20 % 5`	`0`	20 = 5 × 4 + 0 (exato)
`7 % 10`	`7`	Dividendo < divisor
`-10 % 3`	`-1`	Sinal do dividendo
`10 % -3`	`1`	Sinal do dividendo
`5.5 % 2`	`1.5`	Funciona com decimais
`10 % 0`	`NaN`	Divisão por zero

Dicas de Uso

Dica

Para verificar paridade: Use numero % 2 === 0 para par e numero % 2 === 1 para ímpar.

Dica

Para operações cíclicas: O módulo garante que o resultado sempre fique dentro do intervalo [0, divisor-1].

Nota

O operador % em JavaScript é dependente de implementação para números de ponto flutuante, podendo haver pequenas imprecisões devido à aritmética binária.

Aviso

Cuidado com números negativos: o resultado em JavaScript segue o sinal do dividendo, diferente de algumas outras linguagens.