Javascript % (Modulo) Gives a Negative Result for Negative Numbers

javascript

prompt-engineering

interview-preparation

best-practices

byAnton Shumikhin·Feb 26, 2025

When operating with the % (modulus) in JavaScript, utilizing negative values often produces negative results. If you wish to get a positive outcome, a formula like (n % m + m) % m can keep results within the expected range. Here n is your number, and m is the modulus.

Example:

let n = -7, m = 5;
let positiveMod = (n % m + m) % m; // Yielding 3, not so negative now, huh?

In JavaScript, the % is a remainder operator, differing from a traditional modulo operator in various other languages. This can lead to understandably confusing scenarios when working with negative numbers. Adjusting results manually or via a custom modulo function can bring consistency to your calculations.

Know the Difference: Modulo vs Remainder

The remainder and modulo operations are similar twins with a key difference: the signage of their results. A remainder operation can have a result with a negative sign if the left operand is negative. A true modulo operation keeps the sign of the modulus, providing a non-negative result.

Implementing a Modulo Function

A custom modulo function that correctly handles negative numbers provides a foolproof way to avoid the potential pitfalls of the remainder operator. This could be achieved using Math.floor.

function mod(n, m) {
  return ((n % m) + m) % m;
}

Here's a surprise: this makes negative dividends behave!

Avoid Common Misconceptions

Beware of interpreting the JavaScript remainder operator % as a mathematical modulo operation when dealing with negative numbers. Here are common pitfalls:

1. Symmetry: Not Always Symmetrical

The remainder operator % doesn’t exhibit the symmetrical properties of a mathematical modulo operator. When it comes to negative dividends, % reacts differently.

console.log(5 % 3);   // Outputs 2
console.log(-5 % 3);  // Outputs -2, not 1. Plot twist: it's not symmetrical!

2. Language Specifics: Pay Attention

Languages have their specialties. In JavaScript, the sign of % follows the dividend.

3. Performance: Code Isn't Always Elegant

While using Number.prototype to solve the modulo problem might seem elegant, remember, elegance can sometimes be a performance bottleneck.

Using a Consistent Modulo Function

To deal with the remainder operator's quirks, here's an efficient, standalone modulo function that employs Math.floor for correctly dealing with negative dividends.

function mod(n, m) {
  return n - m * Math.floor(n / m);
}

This mod function is your Swiss Army Knife to tackle unexpected results from negative numbers.

Performance: Because It Matters

Consider the performance implications of your chosen strategy. To keep your code efficient, standalone functions typically outperform modifications to existing prototypes.

Testing: Verify Edge Cases

It's always good to verify edge cases, especially those involving negative dividends. This practice helps to ensure your modulo implementation behaves as expected.

console.assert(mod(-13, 64) === 51, "mod(-13, 64) should be 51, else I owe you a coffee!");
console.assert(mod(50, 15) === 5, "mod(50, 15) should be 5, if not, check your calculator settings.");