Executando verificação de segurança...
Em resposta a A grande utilidade do operador % (Módulo)
4
kht

Só pra complementar meu outro comentário, seguem outros usos do operador %.

Obter os últimos dígitos de um número

Você até encontra "soluções" por aí que sugerem transformar o número em string e depois pegar os últimos caracteres. Mas na verdade, para obter os últimos N dígitos, só precisa pegar o resto da divisão por 10N:

var n = 1898453;
var ultimoDigito = n % 10; // 3
var doisUltimosDigitos = n % 100; // 53

Daí a solução pro clássico exercício de somar os dígitos de um número:

var n = 1234;
var soma = 0;
while (n > 0) {
    soma += n % 10; // soma o último dígito
    n = Math.floor(n / 10); // divide por 10, assim o último dígito "cai fora"
}
console.log(soma); // 10

Geralmente a solução matemática é mais rápida e eficiente do que converter o número para string e depois pegar cada caractere e converter de volta para número.

Lembrando que para números negativos, nem sempre funciona, como já comentado aqui. No caso acima, bastaria usar Math.abs(n) antes de usar %, mas claro que cada caso é um caso.

O clássico problema do caixa eletrônico

Esse é um exercício clássico que muitos já devem ter feito. A ideia da solução é relativamente simples: se o valor é 357 eu primeiro divido pela maior nota (por exemplo, 100) para saber quantas eu preciso (no caso, 3). Depois eu pego o resto da divisão por 100 (olha o % aí!), e o resultado será o valor restante (57). E a partir daí eu continuo verificando a próxima nota, e repito isso até o valor zerar.

Algumas "soluções" fazem um loop e vão subtraindo o valor da nota e incrementando um contador, mas o uso de divisão e % simplifica esse processo.

Claro, a solução abaixo é o caso mais simples, em que não há limite na quantidade de notas. E como a menor nota é 1, sempre haverá uma combinação possível. Se quiser uma solução que leva em conta a quantidade de cada nota, além de verificar quando não é possível (por exemplo, valor é 75 mas só tem notas de 100 e 50) veja aqui.

var valor = 357;
var notas = [100, 50, 20, 10, 5, 1];
let quantidades = new Map(); // Map para guardar as quantidades de cada nota
for (const nota of notas) {
    if (valor >= nota) {
        const qtd = Math.floor(valor / nota);
        valor %= nota;
        if (qtd == 0)
            continue;
        quantidades.set(nota, qtd);
        if (valor == 0)
            break; // se o valor zerou, não preciso continuar
    }
}

for (const [nota, qtd] of quantidades)
    console.log(`- ${qtd} nota${qtd == 1 ? "" : "s"} de ${nota}`);

Saída:

- 3 notas de 100
- 1 nota de 50
- 1 nota de 5
- 2 notas de 1

Pegar uma duração total em segundos e converter para horas, minutos e segundos

A menos que a linguagem já ofereça alguma lib pronta, não é difícil fazer os cálculos manualmente, e o operador % pode te ajudar:

// 12123 segundos são quantas horas/minutos/segundos?
var totalSegundos = 12123;

var horas = Math.floor(totalSegundos / 3600);
var minutos = Math.floor(totalSegundos / 60) % 60;
var segundos = totalSegundos % 60;

console.log(`${horas} horas, ${minutos} minutos e ${segundos} segundos`); // 3 horas, 22 minutos e 3 segundos

Ação específica a cada X iterações

Suponha que você quer iterar mil vezes, mas só quer fazer uma ação específica a cada 27 itens:

for (var i = 1; i <= 1000; i++) {
    if (i % 27 == 0) {
        // ação específica feita a cada 27 itens
    }
    // restante das ações
}

Criptografia

Algoritmos criptográficos costumam fazer uso extenso desse operador. Entre alguns exemplos, temos o RSA, Diffie-Hellman, etc. De forma geral, a aritmética modular possui várias características fundamentais para os sistemas criptográficos modernos.

Carregando publicação patrocinada...