Truncate to the nearest 50 in JavaScript

Question

What JavaScript formula can I use to truncate a number to the nearest 50. Example. I wanted 498 > 450

I have tried

Math.round (498, 50 )

And Math.ceil(498, 50)

But am not getting. Please help

Answer 1

This may be a mixup of terminology, mixing terms like "nearest" and "truncate", neither of which quite describes what the example demonstrates.

The example you give always rounds down, never up, to the nearest custom value (in this case 50). To do that you can just subtract the result of % 50. For example:

const val = 498;
console.log(val - val % 50);

Even make it a re-usable function:

const Nearest = (val, num) => val - val % num;

console.log(Nearest(498, 50));

Answer 2

Divide by 50, do the operation, multiply by 50.

console.log(Math.floor(498 / 50) * 50);
console.log(Math.ceil(498 / 50) * 50);
console.log(Math.round(498 / 50) * 50);
console.log(Math.trunc(498 / 50) * 50);

Answer 3

You divide your number by 50, take the ceiling of that number and then multiply it by 50.

Math.ceil(value / 50) * 50;

A quick sidenote: truncate has a whole other meaning for numbers in Javascript: Math.trunc on MDN

Edit:

If you want other rounding semantics than ceil you can of course use floor (always goes to lowest multiple of 50):

Math.floor(451 / 50) * 50; // => 450

Answer 4

You divide by the multiple and round and then multiply by the multiple. If you want the lower bound, you use floor instead of round. If you want the upper bound, you use ceil instead of round. Look at these examples:

let x = 498;

let y = Math.round(498/50)*50;
console.log(y);

y = Math.floor(498/50)*50;
console.log(y);

y = Math.ceil(498/50)*50;
console.log(y);

Answer 5

To do what you want, the Remainder operator is your best friend. This will give you whatever is left over after dividing the number by the nearest number.

If your goal is to always round down, the following function would work. Just take your original number, find the remainder, and remove the remainder:

function roundDownToNearest(num, nearest){
    return num - (num % nearest);
}

console.log(roundDownToNearest(498, 50))

If you always want to round up, you round down, then add the nearest amount:

function roundUpToNearest(num, nearest){
    return num - (num % nearest) + nearest;
}

console.log(roundUpToNearest(498, 50))

If you want to get to the closest of the two, you could do the following. Find your remainder, then see if it's greater or less than half of your nearest value. If it's greater, round up. If less, round down.

function roundToNearest(num, nearest){
     if(num % nearest > nearest / 2){
          return roundUpToNearest(num, nearest);
     } else {
          return roundDownToNearest(num, nearest);
     }
}

console.log(roundToNearest(498, 50))
console.log(roundToNearest(458, 50))