División de enteros en JavaScript

JavaScript no tiene un operador // de división entera. Para valores Number normales, use Math.trunc(dividend / divisor) cuando el cociente deba descartar la parte fraccionaria hacia cero, y % para el resto. Elija Math.floor() solo cuando redondear hacia abajo sea la regla buscada. Estas opciones difieren con valores negativos, por lo que decidir primero la regla es más importante que usar un atajo.

Respuesta directa: elija truncamiento o redondeo hacia abajo

La división entera puede significar dos reglas distintas. Un cociente truncado elimina los decimales: Math.trunc(-13 / 5) da -2. Un cociente con suelo redondea hacia menos infinito: Math.floor(-13 / 5) da -3. Con entradas positivas ambos producen 2, lo que puede ocultar la diferencia hasta que aparezca un valor negativo en producción.

Use truncamiento para tareas que separan una cantidad con signo en cociente y resto con signo. Use división con suelo en cubos basados en cero o índices cíclicos donde el cociente siempre debe bajar. El operador % de JavaScript devuelve un resto, no un módulo matemático siempre no negativo; su signo sigue al dividendo. MDN distingue el operador de resto del módulo matemático.

Cociente y resto Number recomendados

Para entradas Number finitas, Math.trunc y % expresan claramente la relación entre cociente y resto. Es el enfoque recomendado para una división entera normal. Compruebe que el divisor no sea cero: un Number distinto de cero dividido por cero con signo produce Infinity con signo, 0 / 0 es NaN y el resto Number con divisor cero también es NaN. La especificación ECMAScript define estos casos de división y resto.

const dividend = 13;
const divisor = 5;

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

quotient: 2
remainder: 3

El resto también permite comprobar el resultado: para entradas enteras, dividend equivale a divisor * quotient + remainder. Esta relación sirve para validar, pero calcular el cociente con Math.trunc comunica la regla de redondeo con más claridad que derivarla indirectamente.

Operandos negativos y resto con signo

Los operandos negativos delimitan el truncamiento y la semántica de suelo. Con -13 / 5, el truncamiento da -2 y la división con suelo da -3. El resultado de % es -3, porque JavaScript conserva el signo del dividendo en un resto no nulo. Ninguna operación falla con entradas negativas; simplemente responden preguntas 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

Cuando se requiere división con suelo o módulo

Si la aplicación requiere un módulo no negativo con divisor positivo, normalice el resto en vez de suponer que % ya se comporta así. Combínelo con Math.floor para que ambos valores sigan la misma convención de división con suelo. El ejemplo siguiente corresponde a un ciclo de cinco elementos, no a toda tarea de cociente/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 normalización presupone un divisor positivo. Defina y pruebe aparte la convención deseada cuando el divisor pueda ser negativo.

Enteros grandes exactos con BigInt

Number usa valores de punto flotante IEEE-754. No puede representar exactamente todos los enteros fuera del intervalo seguro; antes de confiar en un cociente o resto Number, valide las entradas con Number.isSafeInteger. Para enteros exactos mayores, use valores BigInt de forma coherente. La división BigInt trunca hacia cero y su resto sigue la misma idea de resto con signo.

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

No mezcle operandos Number y BigInt: convierta deliberadamente antes de operar. Un divisor cero BigInt lanza RangeError, a diferencia de un divisor cero Number, por lo que validar entradas sigue siendo útil en ambos casos. MDN documenta la división BigInt, los errores de tipos mezclados y el divisor cero.

Por qué no usar coerción bit a bit ni parseInt

Puede encontrar ~~value o value | 0 como abreviaturas de truncamiento. Evítelas para división entera general: los operadores bit a bit convierten a enteros con signo de 32 bits y cambian los valores fuera de ese intervalo. parseInt sirve para analizar cadenas, no es una API de redondeo numérico. MDN documenta Math.trunc y su diferencia con la conversión bit a bit. El contraste muestra el límite de 32 bits y el uso válido de analizar cadenas.

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 con un valor Number numérico y parseInt(text, 10) solo cuando la entrada sea texto por analizar. Ningún atajo corrige la precisión de punto flotante; use BigInt cuando necesite aritmética exacta con enteros grandes.

Resumen de decisión y limitaciones

Use Math.trunc(a / b) y a % b para la división entera habitual en JavaScript. Use Math.floor(a / b) con módulo normalizado solo cuando se requiera semántica de suelo. Use BigInt para enteros grandes exactos, rechace un divisor cero y nunca mezcle BigInt con Number en una operación. Evite la coerción bit a bit y parseInt como alternativas generales porque resuelven problemas distintos.