Divisão Inteira em JavaScript

JavaScript não tem um operador // de divisão inteira. Para valores Number comuns, use Math.trunc(dividend / divisor) quando o quociente deve descartar a parte fracionária em direção a zero, e % para o resto. Escolha Math.floor() apenas se arredondar para baixo for a regra pretendida. As escolhas diferem para valores negativos; decidir a regra vem antes de escolher um atalho.

Resposta direta: escolha truncamento ou piso

Divisão inteira pode significar duas regras. Um quociente truncado remove os dígitos fracionários: Math.trunc(-13 / 5) é -2. Um quociente com piso arredonda para menos infinito: Math.floor(-13 / 5) é -3. Para entradas positivas ambos produzem 2, o que pode esconder a diferença até surgir um valor negativo em produção.

Use truncamento para separar uma quantidade com sinal em quociente e resto com sinal. Use divisão por piso para compartimentos iniciados em zero ou índices cíclicos, em que o quociente deve sempre descer. O operador % de JavaScript retorna um resto, não um módulo matemático sempre não negativo; seu sinal segue o dividendo. MDN distingue o operador resto do módulo matemático.

Quociente e resto Number recomendados

Para entradas Number finitas, Math.trunc e % deixam explícita a relação quociente/resto. Essa é a abordagem recomendada para uma divisão inteira normal. Verifique que o divisor não seja zero: um Number não zero dividido por zero com sinal produz Infinity com sinal, 0 / 0 é NaN e um resto Number com divisor zero também é NaN. A especificação ECMAScript define esses casos.

const dividend = 13;
const divisor = 5;

console.log(`quotient: ${Math.trunc(dividend / divisor)}`);
console.log(`remainder: ${dividend % divisor}`);

quotient: 2
remainder: 3

O resto também ajuda a verificar o resultado: para entradas inteiras, dividend equivale a divisor * quotient + remainder. A relação é útil para validação, mas calcular o quociente com Math.trunc comunica a regra de arredondamento melhor que derivá-la indiretamente.

Operandos negativos e resto com sinal

Operandos negativos separam truncamento da semântica de piso. Com -13 / 5, o truncamento dá -2; a divisão por piso dá -3. O resultado de % é -3, pois JavaScript mantém o sinal do dividendo para um resto diferente de zero. Nenhuma operação falha com entradas negativas; elas respondem a perguntas diferentes.

const dividend = -13;
const divisor = 5;

console.log(`truncating quotient: ${Math.trunc(dividend / divisor)}`);
console.log(`floor quotient: ${Math.floor(dividend / divisor)}`);
console.log(`remainder: ${dividend % divisor}`);

truncating quotient: -2
floor quotient: -3
remainder: -3

Quando divisão por piso ou módulo é necessária

Se a aplicação exigir módulo não negativo para divisor positivo, normalize o resto em vez de supor que % já se comporta assim. Combine-o com Math.floor para que ambos usem a mesma convenção de divisão por piso. O exemplo serve para um ciclo de cinco itens, não para toda tarefa de quociente/resto.

const dividend = -13;
const divisor = 5;
const quotient = Math.floor(dividend / divisor);
const modulo = ((dividend % divisor) + divisor) % divisor;

console.log(`floor quotient: ${quotient}`);
console.log(`non-negative modulo: ${modulo}`);

floor quotient: -3
non-negative modulo: 2

Esta normalização pressupõe divisor positivo. Defina e teste separadamente a convenção desejada quando o divisor puder ser negativo.

Inteiros grandes exatos com BigInt

Number usa valores de ponto flutuante IEEE-754. Ele não representa todo inteiro exatamente além da faixa segura; valide entradas inteiras com Number.isSafeInteger antes de depender de quociente ou resto Number. Para inteiros exatos maiores, use BigInt de modo consistente. A divisão BigInt trunca em direção a zero e seu resto segue a mesma ideia de sinal.

const dividend = 13n;
const divisor = 5n;

console.log(`quotient: ${dividend / divisor}`);
console.log(`remainder: ${dividend % divisor}`);

try {
  13n / 0n;
} catch (error) {
  console.log(`zero divisor: ${error.name}`);
}

try {
  13n / 5;
} catch (error) {
  console.log(`mixed types: ${error.name}`);
}

quotient: 2
remainder: 3
zero divisor: RangeError
mixed types: TypeError

Não misture operandos Number e BigInt: converta deliberadamente antes da aritmética. Um divisor zero BigInt lança RangeError, ao contrário de um divisor zero Number; validar a entrada continua útil nos dois casos. MDN documenta divisão BigInt, erros de tipos mistos e divisor zero.

Por que não usar coerção bit a bit nem parseInt

Você pode ver ~~value ou value | 0 como formas compactas de truncamento. Evite-as na divisão inteira geral: operadores bit a bit convertem para inteiro assinado de 32 bits e alteram valores fora da faixa. parseInt serve para analisar strings, não para arredondamento numérico. MDN documenta Math.trunc e a diferença para conversão bit a bit. A comparação mostra o limite de 32 bits e a análise legítima de texto.

const value = 2 ** 32 + 1;

console.log(`Math.trunc: ${Math.trunc(value)}`);
console.log(`~~value: ${~~value}`);
console.log(`value | 0: ${value | 0}`);
console.log(`parseInt("13.8", 10): ${parseInt("13.8", 10)}`);

Math.trunc: 4294967297
~~value: 1
value | 0: 1
parseInt("13.8", 10): 13

Use Math.trunc para um valor Number numérico e parseInt(text, 10) apenas quando a entrada for texto a analisar. Nenhum atalho corrige a precisão de ponto flutuante; use BigInt quando for necessária aritmética exata com inteiros grandes.

Resumo da decisão e limitações

Use Math.trunc(a / b) e a % b para a divisão inteira usual em JavaScript. Use Math.floor(a / b) com módulo normalizado apenas quando a semântica de piso for necessária. Use BigInt para inteiros grandes exatos, rejeite divisor zero e nunca misture BigInt com Number numa operação. Evite coerção bit a bit e parseInt como alternativas gerais, pois resolvem problemas diferentes.