Division entière en JavaScript

JavaScript ne possède pas d’opérateur // de division entière. Pour des valeurs Number ordinaires, utilisez Math.trunc(dividend / divisor) lorsque le quotient doit supprimer la partie fractionnaire vers zéro, et % pour le reste. Choisissez Math.floor() seulement si l’arrondi inférieur est la règle voulue. Ces choix diffèrent avec les valeurs négatives : la règle importe donc davantage qu’un raccourci.

Réponse directe : choisir la troncature ou le plancher

La division entière peut désigner deux règles. Un quotient tronqué enlève les chiffres fractionnaires : Math.trunc(-13 / 5) vaut -2. Un quotient par plancher arrondit vers moins l’infini : Math.floor(-13 / 5) vaut -3. Pour des entrées positives, les deux donnent 2, ce qui peut cacher la différence jusqu’à l’arrivée d’une valeur négative en production.

Employez la troncature pour séparer une quantité signée en quotient et reste signé. Employez la division par plancher pour des compartiments à indice zéro ou un index cyclique où le quotient doit toujours descendre. L’opérateur % de JavaScript renvoie un reste, pas un modulo selon la convention non négative, où zéro est aussi un résultat valide ; son signe suit le dividende. MDN distingue l’opérateur reste du modulo mathématique.

Quotient et reste Number recommandés

Pour des entrées Number finies, Math.trunc et % rendent explicite la relation quotient/reste. C’est l’approche recommandée pour une division entière courante. Vérifiez que le diviseur n’est pas nul : un Number non nul divisé par zéro signé produit Infinity signé, 0 / 0 vaut NaN, et un reste Number avec diviseur zéro vaut aussi NaN. La spécification ECMAScript définit ces cas.

const dividend = 13;
const divisor = 5;

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

quotient: 2
remainder: 3

Le reste aide aussi à vérifier le résultat : pour des entiers, dividend est égal à divisor * quotient + remainder. Cette relation est utile à la validation, mais calculer le quotient avec Math.trunc exprime la règle d’arrondi plus clairement qu’une dérivation indirecte.

Opérandes négatifs et reste signé

Les opérandes négatifs séparent la troncature de la sémantique par plancher. Avec -13 / 5, la troncature donne -2 et le plancher donne -3. Le résultat % est -3, car JavaScript conserve le signe du dividende pour un reste non nul. Aucune opération n’échoue pour une entrée négative ; elles répondent simplement à des questions différentes.

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

Quand la division par plancher ou le modulo est requis

Si l’application exige un modulo non négatif avec un diviseur positif, normalisez le reste au lieu de supposer que % le fait déjà. Associez-le à Math.floor afin que les deux valeurs suivent la même convention par plancher. L’exemple convient à un cycle de cinq éléments, pas à toute tâche quotient/reste.

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

Cette normalisation suppose un diviseur positif. Définissez et testez séparément la convention voulue lorsqu’un diviseur peut être négatif.

Grands entiers exacts avec BigInt

Number utilise des valeurs flottantes IEEE-754. Il ne représente pas exactement tout entier au-delà de la plage sûre ; validez donc les entrées avec Number.isSafeInteger avant de vous fier à un quotient ou reste Number. Pour des entiers exacts plus grands, utilisez systématiquement BigInt. La division BigInt tronque vers zéro et son reste suit la même règle signée.

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

Ne mélangez pas les opérandes Number et BigInt : convertissez volontairement avant le calcul. Un diviseur nul BigInt lève RangeError, contrairement à un diviseur nul Number ; la validation des entrées reste donc utile dans les deux cas. MDN documente la division BigInt, les erreurs de types mélangés et le diviseur nul.

Pourquoi éviter la coercition binaire et parseInt

Vous verrez parfois ~~value ou value | 0 comme idiome compact de troncature. Évitez-les pour la division entière générale : les opérateurs binaires coercissent vers un entier signé de 32 bits et changent les valeurs hors plage. parseInt sert à analyser des chaînes, pas à arrondir un nombre. MDN documente Math.trunc et sa différence avec la conversion binaire. La comparaison montre la limite de coercition 32 bits et l’analyse valable d’une chaîne.

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

Utilisez Math.trunc pour une valeur Number numérique et parseInt(text, 10) seulement si l’entrée est un texte à analyser. Aucun raccourci ne répare la précision flottante ; utilisez BigInt lorsque l’arithmétique exacte sur de grands entiers est nécessaire.

Résumé de décision et limites

Utilisez Math.trunc(a / b) et a % b pour la division entière JavaScript habituelle. Utilisez Math.floor(a / b) avec un modulo normalisé seulement si la sémantique par plancher est requise. Utilisez BigInt pour les grands entiers exacts, refusez un diviseur nul et ne mélangez jamais BigInt et Number dans une opération. Évitez la coercition binaire et parseInt comme solutions générales : elles résolvent d’autres problèmes.