# Round to at most 2 decimal places (only if necessary)

stinkycheeseman Source

I'd like to round at most 2 decimal places, but only if necessary.

Input:

``````10
1.7777777
9.1
``````

Output:

``````10
1.78
9.1
``````

How can I do this in `JavaScript`?

javascriptdecimalroundingdecimal-point

answered 6 years ago Brian Ustas #1

Use `Math.round(num * 100) / 100`

answered 6 years ago totten #2

``````var result = (Math.round(input*100)/100);
``````

Math.round(num) vs num.toFixed(0) and browser inconsistencies

answered 6 years ago AceCorban #3

Consider `.toFixed()` and `.toPrecision()`:

http://www.javascriptkit.com/javatutors/formatnumber.shtml

answered 6 years ago Shreedhar #4

It may work for you,

``````Math.round(num * 100)/100;
``````

to know the difference between toFixed and round. You can have a look at Math.round(num) vs num.toFixed(0) and browser inconsistencies.

answered 6 years ago JayDM #5

Here is a simple way to do it:

``````Math.round(value * 100) / 100
``````

You might want to go ahead and make a separate function to do it for you though:

``````function roundToTwo(value) {
return(Math.round(value * 100) / 100);
}
``````

Then you would simply pass in the value.

You could enhance it to round to any arbitrary number of decimals by adding a second parameter.

``````function myRound(value, places) {
var multiplier = Math.pow(10, places);

return (Math.round(value * multiplier) / multiplier);
}
``````

answered 6 years ago A Kunin #6

If the value is a text type:

``````parseFloat("123.456").toFixed(2);
``````

If the value is a number:

``````var numb = 123.23454;
numb = numb.toFixed(2);
``````

There is a downside that values like 1.5 will give "1.50" as the output. A fix suggested by @minitech:

``````var numb = 1.5;
numb = +numb.toFixed(2);
// Note the plus sign that drops any "extra" zeroes at the end.
// It changes the result (which is a string) into a number again (think "0 + foo"),
// which means that it uses only as many digits as necessary.
``````

It seems like `Math.round` is a better solution. But it is not! In some cases it will NOT round correctly:

``````Math.round(1.005 * 1000)/1000 // Returns 1 instead of expected 1.01!
``````

toFixed() also will NOT round correctly in some cases (tested in Chrome v.55.0.2883.87)!

Examples:

``````parseFloat("1.555").toFixed(2); // Returns 1.55 instead of 1.56.
parseFloat("1.5550").toFixed(2); // Returns 1.55 instead of 1.56.
// However, it will return correct result if you round 1.5551.
parseFloat("1.5551").toFixed(2); // Returns 1.56 as expected.

1.3555.toFixed(3) // Returns 1.355 instead of expected 1.356.
// However, it will return correct result if you round 1.35551.
1.35551.toFixed(2); // Returns 1.36 as expected.
``````

I guess, this is because 1.555 is actually something like float 1.55499994 behind the scenes.

Solution 1 is to use a script with required rounding algorithm, for example:

``````function roundNumber(num, scale) {
if(!("" + num).includes("e")) {
return +(Math.round(num + "e+" + scale)  + "e-" + scale);
} else {
var arr = ("" + num).split("e");
var sig = ""
if(+arr[1] + scale > 0) {
sig = "+";
}
return +(Math.round(+arr[0] + "e" + sig + (+arr[1] + scale)) + "e-" + scale);
}
}
``````

https://plnkr.co/edit/uau8BlS1cqbvWPCHJeOy?p=preview

Solution 2 is to avoid front end calculations and pull rounded values from the backend server.

None of the answers found here is correct. @stinkycheeseman asked to round up, you all rounded the number.

To round up, use this:

``````Math.ceil(num * 100)/100;
``````

answered 5 years ago Andrei #8

Here is a function I came up with to do "round up". I used double Math.round to compensate for JavaScript's inaccurate multiplying, so 1.005 will be correctly rounded as 1.01.

``````function myRound(number, decimalplaces){
if(decimalplaces > 0){
var multiply1 = Math.pow(10,(decimalplaces + 4));
var divide1 = Math.pow(10, decimalplaces);
return Math.round(Math.round(number * multiply1)/10000 )/divide1;
}
if(decimalplaces < 0){
var divide2 = Math.pow(10, Math.abs(decimalplaces));
var multiply2 = Math.pow(10, Math.abs(decimalplaces));
return Math.round(Math.round(number / divide2) * multiply2);
}
return Math.round(number);
}
``````

answered 5 years ago vsvasya #9

I wrote the following set of functions for myself. Maybe it will help you too.

``````function float_exponent(number) {
exponent = 1;
while (number < 1.0) {
exponent += 1
number *= 10
}
return exponent;
}
function format_float(number, extra_precision) {
precision = float_exponent(number) + (extra_precision || 0)
return number.toFixed(precision).split(/\.?0+\$/)[0]
}
``````

Usage:

``````format_float(1.01); // 1
format_float(1.06); // 1.1
format_float(0.126); // 0.13
format_float(0.000189); // 0.00019
``````

For you case:

``````format_float(10, 1); // 10
format_float(9.1, 1); // 9.1
format_float(1.77777, 1); // 1.78
``````

answered 5 years ago coreyavis #10

I still don't think anyone gave him the answer to how to only do the rounding if needed. The easiest way I see to do it is to check if there is even a decimal in the number, like so:

``````var num = 3.21;
if ( (num+"").indexOf('.') >= 0 ) { //at least assert to string first...
// whatever code you decide to use to round
}
``````

answered 5 years ago arielf #11

Here is a prototype method:

``````Number.prototype.round = function(places){
places = Math.pow(10, places);
return Math.round(this * places)/places;
}

var yournum = 10.55555;
yournum = yournum.round(2);
``````

answered 5 years ago MarkG #12

You can use

``````function roundToTwo(num) {
return +(Math.round(num + "e+2")  + "e-2");
}
``````

I found this over on MDN. Their way avoids the problem with 1.005 that was mentioned.

``````roundToTwo(1.005)
1.01
roundToTwo(10)
10
roundToTwo(1.7777777)
1.78
roundToTwo(9.1)
9.1
roundToTwo(1234.5678)
1234.57
``````

answered 5 years ago Daniel De León #13

To not deal with many 0s, use this variant:

``````Math.round(num * 1e2) / 1e2
``````

answered 5 years ago Lavamantis #14

MarkG's answer is the correct one. Here's a generic extension for any number of decimal places.

``````Number.prototype.round = function(places) {
return +(Math.round(this + "e+" + places)  + "e-" + places);
}
``````

Usage:

``````var n = 1.7777;
n.round(2); // 1.78
``````

Unit test:

``````it.only('should round floats to 2 places', function() {

var cases = [
{ n: 10,      e: 10,    p:2 },
{ n: 1.7777,  e: 1.78,  p:2 },
{ n: 1.005,   e: 1.01,  p:2 },
{ n: 1.005,   e: 1,     p:0 },
{ n: 1.77777, e: 1.8,   p:1 }
]

cases.forEach(function(testCase) {
var r = testCase.n.round(testCase.p);
assert.equal(r, testCase.e, 'didn\'t get right number');
});
})
``````

answered 5 years ago astorije #15

MarkG and Lavamantis offered a much better solution than the one that has been accepted. It's a shame they don't get more upvotes!

Here is the function I use to solve the floating point decimals issues also based on MDN. It is even more generic (but less concise) than Lavamantis's solution:

``````function round(value, exp) {
if (typeof exp === 'undefined' || +exp === 0)
return Math.round(value);

value = +value;
exp  = +exp;

if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0))
return NaN;

// Shift
value = value.toString().split('e');
value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)));

// Shift back
value = value.toString().split('e');
return +(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp));
}
``````

Use it with:

``````round(10.8034, 2);      // Returns 10.8
round(1.275, 2);        // Returns 1.28
round(1.27499, 2);      // Returns 1.27
round(1.2345678e+2, 2); // Returns 123.46
``````

Compared to Lavamantis's solution, we can do...

``````round(1234.5678, -2); // Returns 1200
round("123.45");      // Returns 123
``````

answered 4 years ago Scott Stafford #16

If you happen to already be using the d3 library, they have a powerful number formatting library: https://github.com/mbostock/d3/wiki/Formatting

Rounding specifically is here: https://github.com/mbostock/d3/wiki/Formatting#d3_round

``````> d3.round(1.777777, 2)
1.78
> d3.round(1.7, 2)
1.7
> d3.round(1, 2)
1
``````

answered 4 years ago user3711536 #17

``````+(10).toFixed(2); // = 10
+(10.12345).toFixed(2); // = 10.12

(10).toFixed(2); // = 10.00
(10.12345).toFixed(2); // = 10.12
``````

answered 4 years ago user3447070 #18

Try to use the jQuery .number plug-in:

``````var number = 19.8000000007;
var res = 1 * \$.number(number, 2);
``````

answered 4 years ago user #19

A precise rounding method. Source: Mozilla

``````(function(){

/**
* Decimal adjustment of a number.
*
* @param   {String}    type    The type of adjustment.
* @param   {Number}    value   The number.
* @param   {Integer}   exp     The exponent (the 10 logarithm of the adjustment base).
* @returns {Number}            The adjusted value.
*/
// If the exp is undefined or zero...
if (typeof exp === 'undefined' || +exp === 0) {
return Math[type](value);
}
value = +value;
exp = +exp;
// If the value is not a number or the exp is not an integer...
if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
return NaN;
}
// Shift
value = value.toString().split('e');
value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
// Shift back
value = value.toString().split('e');
return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
}

// Decimal round
if (!Math.round10) {
Math.round10 = function(value, exp) {
};
}
// Decimal floor
if (!Math.floor10) {
Math.floor10 = function(value, exp) {
};
}
// Decimal ceil
if (!Math.ceil10) {
Math.ceil10 = function(value, exp) {
};
}
})();
``````

Examples:

``````// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
Math.round10(1.005, -2); // 1.01 -- compare this with Math.round(1.005*100)/100 above
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
``````

answered 4 years ago Deele #20

I just wanted to share my approach, based on previously mentioned answers:

Let's create a function that rounds any given numeric value to a given amount of decimal places:

``````function roundWDecimals(n, decimals) {
if (!isNaN(parseFloat(n)) && isFinite(n)) {
if (typeof(decimals) == typeof(undefined)) {
decimals = 0;
}
var decimalPower = Math.pow(10, decimals);
return Math.round(parseFloat(n) * decimalPower) / decimalPower;
}
return NaN;
}
``````

And introduce a new "round" method for numbers prototype:

``````Object.defineProperty(Number.prototype, 'round', {
enumerable: false,
value: function(decimals) {
return roundWDecimals(this, decimals);
}
});
``````

And you can test it:

``````function roundWDecimals(n, decimals) {
if (!isNaN(parseFloat(n)) && isFinite(n)) {
if (typeof(decimals) == typeof(undefined)) {
decimals = 0;
}
var decimalPower = Math.pow(10, decimals);
return Math.round(parseFloat(n) * decimalPower) / decimalPower;
}
return NaN;
}
Object.defineProperty(Number.prototype, 'round', {
enumerable: false,
value: function(decimals) {
return roundWDecimals(this, decimals);
}
});

var roundables = [
{num: 10, decimals: 2},
{num: 1.7777777, decimals: 2},
{num: 9.1, decimals: 2},
{num: 55.55, decimals: 1},
{num: 55.549, decimals: 1},
{num: 55, decimals: 0},
{num: 54.9, decimals: 0},
{num: -55.55, decimals: 1},
{num: -55.551, decimals: 1},
{num: -55, decimals: 0},
{num: 1.005, decimals: 2},
{num: 1.005, decimals: 2},
{num: 19.8000000007, decimals: 2},
],
table = '<table border="1"><tr><th>Num</th><th>Decimals</th><th>Result</th></tr>';
\$.each(roundables, function() {
table +=
'<tr>'+
'<td>'+this.num+'</td>'+
'<td>'+this.decimals+'</td>'+
'<td>'+this.num.round(this.decimals)+'</td>'+
'</tr>'
;
});
table += '</table>';
\$('.results').append(table);``````
``````<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<div class="results"></div>``````

answered 4 years ago Harish.bazee #21

Use this function Number(x).toFixed(2);

answered 4 years ago petermeissner #22

Try this light weight solution:

``````function round(x, digits){
return parseFloat(x.toFixed(digits))
}

round(1.222,  2) ;
// 1.22
round(1.222, 10) ;
// 1.222
``````

answered 4 years ago Gourav Singla #23

One can use `.toFixed(NumberOfDecimalPlaces)`.

``````var str = 10.234.toFixed(2); // => '10.23'
var number = Number(str); // => 10.23
``````

answered 4 years ago nottinhill #24

### Node.js

This did the trick for me on Node.js in a matter of seconds:

``````npm install math
``````

Source: http://mathjs.org/examples/basic_usage.js.html

answered 4 years ago Edmund #25

Easiest way:

`+num.toFixed(2)`

It converts it to a string, and then back into an integer / float.

answered 4 years ago Arne H. Bitubekk #26

You could also override the Math.round function to do the rounding correct and add a parameter for decimals and use it like: Math.round(Number, Decimals). Keep in mind that this overrides the built in component Math.round and giving it another property then it original is.

``````var round = Math.round;
Math.round = function (value, decimals) {
decimals = decimals || 0;
return Number(round(value + 'e' + decimals) + 'e-' + decimals);
}
``````

Then you can simply use it like this:

``````Math.round(1.005, 2);
``````

https://jsfiddle.net/k5tpq3pd/3/

answered 3 years ago momo #27

Here is the shortest and complete answer:

``````function round(num, decimals) {
var n = Math.pow(10, decimals);
return Math.round( (n * num).toFixed(decimals) )  / n;
};
``````

This also takes care of the example case 1.005 which will return 1.01.

answered 3 years ago Ritesh Dhuri #28

``````var roundUpto = function(number, upto){
return Number(number.toFixed(upto));
}
roundUpto(0.1464676, 2);
``````

`toFixed(2)` here 2 is number of digits upto which we want to round this num.

answered 3 years ago Javarome #29

One way to achieve such a rounding only if necessary is to use Number.prototype.toLocaleString():

``````myNumber.toLocaleString('en', {maximumFractionDigits:2, useGrouping:false})
``````

This will provide exactly the output you expect, but as strings. You can still convert those back to numbers if that's not the data type you expect.

answered 3 years ago stanleyxu2005 #30

There are a couple of ways to do that. For people like me, the Lodash's variant

``````function round(number, precision) {
var pair = (number + 'e').split('e')
var value = Math.round(pair[0] + 'e' + (+pair[1] + precision))
pair = (value + 'e').split('e')
return +(pair[0] + 'e' + (+pair[1] - precision))
}
``````

Usage:

``````round(0.015, 2) // 0.02
round(1.005, 2) // 1.01
``````

If your project uses jQuery or lodash, you can also find proper `round` method in the libraries.

## Update 1

I removed the variant `n.toFixed(2)`, because it is not correct. Thank you @avalanche1

answered 2 years ago loretoparisi #31

To round at decimal positions `pos` (including no decimals) do `Math.round(num * Math.pow(10,pos)) / Math.pow(10,pos)`

``````var console = {
log: function(s) {
document.getElementById("console").innerHTML += s + "<br/>"
}
}
var roundDecimals=function(num,pos) {
return (Math.round(num * Math.pow(10,pos)) / Math.pow(10,pos) );
}
//https://en.wikipedia.org/wiki/Pi
var pi=3.14159265358979323846264338327950288419716939937510;
for(var i=2;i<15;i++) console.log("pi="+roundDecimals(pi,i));
for(var i=15;i>=0;--i) console.log("pi="+roundDecimals(pi,i));``````
``<div id="console" />``

answered 2 years ago Nimesh #32

Please use the below function if you don't want to round off.

``````function ConvertToDecimal(num) {
num = num.toString(); // If it's not already a String
num = num.slice(0, (num.indexOf(".")) + 3); // With 3 exposing the hundredths place
alert('M : ' + Number(num)); // If you need it back as a Number
}
``````

answered 2 years ago Marcos Lima #33

I'll add one more approach to this.

``````number = 16.6666666;
console.log(parseFloat(number.toFixed(2)));
"16.67"

number = 16.6;
console.log(parseFloat(number.toFixed(2)));
"16.6"

number = 16;
console.log(parseFloat(number.toFixed(2)));
"16"
``````

`.toFixed(2)` returns a string with exactily 2 decimal points, that may or may not be trailing zeros. Doing a `parseFloat()` will eliminate those trailing zeros.

answered 2 years ago Mark Amery #34

This question is complicated.

Suppose we have a function, `roundTo2DP(num)`, that takes a float as an argument and returns a value rounded to 2 decimal places. What should each of these expressions evaluate to?

• `roundTo2DP(0.014999999999999999)`
• `roundTo2DP(0.0150000000000000001)`
• `roundTo2DP(0.015)`

The 'obvious' answer is that the first example should round to 0.01 (because it's closer to 0.01 than to 0.02) while the other two should round to 0.02 (because 0.0150000000000000001 is closer to 0.02 than to 0.01, and because 0.015 is exactly halfway between them and there is a mathematical convention that such numbers get rounded up).

The catch, which you may have guessed, is that `roundTo2DP` cannot possibly be implemented to give those obvious answers, because all three numbers passed to it are the same number. IEEE 754 binary floating point numbers (the kind used by JavaScript) can't exactly represent most non-integer numbers, and so all three numeric literals above get rounded to a nearby valid floating point number. This number, as it happens, is exactly

0.01499999999999999944488848768742172978818416595458984375

which is closer to 0.01 than to 0.02.

You can see that all three numbers are the same at your browser console, Node shell, or other JavaScript interpreter. Just compare them:

``````> 0.014999999999999999 === 0.0150000000000000001
true``````

So when I write `m = 0.0150000000000000001`, the exact value of `m` that I end up with is closer to `0.01` than it is to `0.02`. And yet, if I convert `m` to a String...

``````> var m = 0.0150000000000000001;
> console.log(String(m));
0.015
> var m = 0.014999999999999999;
> console.log(String(m));
0.015``````

... I get 0.015, which should round to 0.02, and which is noticeably not the 56-decimal-place number I earlier said that all of these numbers were exactly equal to. So what dark magic is this?

The answer can be found in the ECMAScript specification, in section 7.1.12.1: ToString applied to the Number type. Here the rules for converting some Number m to a String are laid down. The key part is point 5, in which an integer s is generated whose digits will be used in the String representation of m:

let n, k, and s be integers such that k ≥ 1, 10k-1s < 10k, the Number value for s × 10n-k is m, and k is as small as possible. Note that k is the number of digits in the decimal representation of s, that s is not divisible by 10, and that the least significant digit of s is not necessarily uniquely determined by these criteria.

The key part here is the requirement that "k is as small as possible". What that requirement amounts to is a requirement that, given a Number `m`, the value of `String(m)` must have the least possible number of digits while still satisfying the requirement that `Number(String(m)) === m`. Since we already know that `0.015 === 0.0150000000000000001`, it's now clear why `String(0.0150000000000000001) === '0.015'` must be true.

Of course, none of this discussion has directly answered what `roundTo2DP(m)` should return. If `m`'s exact value is 0.01499999999999999944488848768742172978818416595458984375, but its String representation is '0.015', then what is the correct answer - mathematically, practically, philosophically, or whatever - when we round it to two decimal places?

There is no single correct answer to this. It depends upon your use case. You probably want to respect the String representation and round upwards when:

• The value being represented is inherently discrete, e.g. an amount of currency in a 3-decimal-place currency like dinars. In this case, the true value of a Number like 0.015 is 0.015, and the 0.0149999999... representation that it gets in binary floating point is a rounding error. (Of course, many will argue, reasonably, that you should use a decimal library for handling such values and never represent them as binary floating point Numbers in the first place.)
• The value was typed by a user. In this case, again, the exact decimal number entered is more 'true' than the nearest binary floating point representation.

On the other hand, you probably want to respect the binary floating point value and round downwards when your value is from an inherently continuous scale - for instance, if it's a reading from a sensor.

These two approaches require different code. To respect the String representation of the Number, we can (with quite a bit of reasonably subtle code) implement our own rounding that acts directly on the String representation, digit by digit, using the same algorithm you would've used in school when you were taught how to round numbers. Below is an example which respects the OP's requirement of representing the number to 2 decimal places "only when necessary" by stripping trailing zeroes after the decimal point; you may, of course, need to tweak it to your precise needs.

``````/**
* Converts num to a decimal string (if it isn't one already) and then rounds it
* to at most dp decimal places.
*
* For explanation of why you'd want to perform rounding operations on a String
* rather than a Number, see http://stackoverflow.com/a/38676273/1709587
*
* @param {(number|string)} num
* @param {number} dp
* @return {string}
*/
function roundStringNumberWithoutTrailingZeroes (num, dp) {
if (arguments.length != 2) throw new Error("2 arguments required");

num = String(num);
if (num.indexOf('e+') != -1) {
// Can't round numbers this large because their string representation
// contains an exponent, like 9.99e+37
throw new Error("num too large");
}
if (num.indexOf('.') == -1) {
// Nothing to do
return num;
}

var parts = num.split('.'),
beforePoint = parts[0],
afterPoint = parts[1],
shouldRoundUp = afterPoint[dp] >= 5,
finalNumber;

afterPoint = afterPoint.slice(0, dp);
if (!shouldRoundUp) {
finalNumber = beforePoint + '.' + afterPoint;
} else if (/^9+\$/.test(afterPoint)) {
// If we need to round up a number like 1.9999, increment the integer
// before the decimal point and discard the fractional part.
finalNumber = Number(beforePoint)+1;
} else {
// Starting from the last digit, increment digits until we find one
// that is not 9, then stop
var i = dp-1;
while (true) {
if (afterPoint[i] == '9') {
afterPoint = afterPoint.substr(0, i) +
'0' +
afterPoint.substr(i+1);
i--;
} else {
afterPoint = afterPoint.substr(0, i) +
(Number(afterPoint[i]) + 1) +
afterPoint.substr(i+1);
break;
}
}

finalNumber = beforePoint + '.' + afterPoint;
}

// Remove trailing zeroes from fractional part before returning
return finalNumber.replace(/0+\$/, '')
}
``````

Example usage:

``````> roundStringNumberWithoutTrailingZeroes(1.6, 2)
'1.6'
> roundStringNumberWithoutTrailingZeroes(10000, 2)
'10000'
> roundStringNumberWithoutTrailingZeroes(0.015, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.015000', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(1, 1)
'1'
> roundStringNumberWithoutTrailingZeroes('0.015', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(0.01499999999999999944488848768742172978818416595458984375, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.01499999999999999944488848768742172978818416595458984375', 2)
'0.01'``````

The function above is probably what you want to use to avoid users ever witnessing numbers that they have entered being rounded wrongly.

(As an alternative, you could also try the round10 library which provides a similarly-behaving function with a wildly different implementation.)

But what if you have the second kind of Number - a value taken from a continuous scale, where there's no reason to think that approximate decimal representations with fewer decimal places are more accurate than those with more? In that case, we don't want to respect the String representation, because that representation (as explained in the spec) is already sort-of-rounded; we don't want to make the mistake of saying "0.014999999...375 rounds up to 0.015, which rounds up to 0.02, so 0.014999999...375 rounds up to 0.02".

Here we can simply use the built-in `toFixed` method. Note that by calling `Number()` on the String returned by `toFixed`, we get a Number whose String representation has no trailing zeroes (thanks to the way JavaScript computes the String representation of a Number, discussed earlier in this answer).

``````/**
* Takes a float and rounds it to at most dp decimal places. For example
*
*     roundFloatNumberWithoutTrailingZeroes(1.2345, 3)
*
* returns 1.234
*
* Note that since this treats the value passed to it as a floating point
* number, it will have counterintuitive results in some cases. For instance,
*
*     roundFloatNumberWithoutTrailingZeroes(0.015, 2)
*
* gives 0.01 where 0.02 might be expected. For an explanation of why, see
* http://stackoverflow.com/a/38676273/1709587. You may want to consider using the
*
* @param {number} num
* @param {number} dp
* @return {number}
*/
function roundFloatNumberWithoutTrailingZeroes (num, dp) {
var numToFixedDp = Number(num).toFixed(dp);
return Number(numToFixedDp);
}
``````

answered 2 years ago Soldeplata Saketos #35

This is the simplest, more elegant solution (and I am the best of the world;):

``````function roundToX(num, X) {
return +(Math.round(num + "e+"+X)  + "e-"+X);
}
//roundToX(66.66666666,2) => 66.67
//roundToX(10,2) => 10
//roundToX(10.904,2) => 10.9
``````

answered 2 years ago cronvel #36

You should use:

``````Math.round( num * 100 + Number.EPSILON ) / 100
``````

No one seems to be aware of `Number.EPSILON`.

Also it's worth noting that this is not a JavaScript weirdness like some people stated.

That is simply the way floating point numbers works in a computer. Like 99% of programming languages, JavaScript doesn't have home made floating point numbers; it relies on the CPU/FPU for that. A computer uses binary, and in binary, there isn't any numbers like `0.1`, but a mere binary approximation for that. Why? For the same reason than 1/3 cannot be written in decimal: its value is 0.33333333... with an infinity of threes.

Here come `Number.EPSILON`. That number is the difference between 1 and the next number existing in the double precision floating point numbers. That's it: There is no number between `1` and 1 + `Number.EPSILON`.

EDIT:

As asked in the comments, let's clarify one thing: adding `Number.EPSILON` is relevant only when the value to round is the result of an arithmetic operation, as it can swallow some floating point error delta.

It's not useful when the value comes from a direct source (e.g.: literal, user input or sensor).

answered 2 years ago Martin #37

Just for the record, the scaling method could theoretically return Infinity if the number and the digits you want to round to are big enough. In JavaScript that shouldn't be a problem since the maximum number is 1.7976931348623157e+308, but if you're working with really big numbers or a lot of decimal places you could try this function instead:

``````Number.prototype.roundTo = function(digits)
{
var str = this.toString();
var split = this.toString().split('e');
var scientific = split.length > 1;
var index;
if (scientific)
{
str = split[0];
var decimal = str.split('.');
if (decimal.length < 2)
return this;
index = decimal[0].length + 1 + digits;
}
else
index = Math.floor(this).toString().length + 1 + digits;
if (str.length <= index)
return this;
var digit = str[index + 1];
var num = Number.parseFloat(str.substring(0, index));
if (digit >= 5)
{
var extra = Math.pow(10, -digits);
return this < 0 ? num - extra : num + extra;
}
if (scientific)
num += "e" + split[1];
return num;
}``````

answered 1 year ago RBZ #38

A Generic Answer for all browsers and precisions:

``````function round(num, places) {
if(!places){
return Math.round(num);
}

var val = Math.pow(10, places);
return Math.round(num * val) / val;
}

round(num, 2);
``````

If you are using lodash library, you can use the round method of lodash like following.

``````_.round(number, precision)
``````

Eg:

``````_.round(1.7777777, 2) = 1.78
``````

answered 1 year ago Suganth G #40

I tried my very own code, try this

``````function AmountDispalyFormat(value) {
value = value.toFixed(3);
var amount = value.toString().split('.');
var result = 0;
if (amount.length > 1) {
var secondValue = parseInt(amount[1].toString().slice(0, 2));
if (amount[1].toString().length > 2) {
if (parseInt(amount[1].toString().slice(2, 3)) > 4) {
secondValue++;
if (secondValue == 100) {
amount[0] = parseInt(amount[0]) + 1;
secondValue = 0;
}
}
}

if (secondValue.toString().length == 1) {
secondValue = "0" + secondValue;
}
result = parseFloat(amount[0] + "." + secondValue);
} else {
result = parseFloat(amount);
}
return result;
}
``````

A simpler ES6 way is

``````const round = (x, n) =>
parseFloat(Math.round(x * Math.pow(10, n)) / Math.pow(10, n)).toFixed(n);
``````

This pattern also returns the precision asked for.

ex:

``````round(44.7826456, 4)  // yields 44.7826
round(78.12, 4)       // yields 78.1200
``````

answered 11 months ago pery mimon #42

2017
Just use native code `.toFixed()`

``````number = 1.2345;
number.toFixed(2) // "1.23"
``````

If you need to be strict and add digits just if needed it can use `replace`

``````number = 1; // "1"
number.toFixed(5).replace(/\.?0*\$/g,'');
``````

answered 9 months ago Nicolo #43

I know there are many answers, but most of them have side effect in some specific cases.

Easiest and shortest solution without any side effects is following:

``````Number((2.3456789).toFixed(2)) // 2.35
``````

It rounds properly and returns number instead of string

``````console.log(Number((2.345).toFixed(2)))  // 2.35
console.log(Number((2.344).toFixed(2)))  // 2.34
console.log(Number((2).toFixed(2)))      // 2
console.log(Number((-2).toFixed(2)))     // -2
console.log(Number((-2.345).toFixed(2))) // -2.35

console.log(Number((2.345678).toFixed(3))) // 2.346
``````

answered 9 months ago Elid Garazlic #44

``````number=(parseInt((number +0.005)*100))/100;
``````

add 0.005 if you want to normal round (2 decimals)

``````8.123 +0.005=> 8.128*100=>812/100=>8.12

8.126 +0.005=> 8.131*100=>813/100=>8.13
``````

answered 7 months ago Matas Vaitkevicius #45

Since ES6 there is a 'proper' way (without overriding statics and creating workarounds) to do this by using toPrecision

``````var x = 1.49999999999;
console.log(x.toPrecision(4));
console.log(x.toPrecision(3));
console.log(x.toPrecision(2));

var y = Math.PI;
console.log(y.toPrecision(6));
console.log(y.toPrecision(5));
console.log(y.toPrecision(4));

var z = 222.987654
console.log(z.toPrecision(6));
console.log(z.toPrecision(5));
console.log(z.toPrecision(4));``````

answered 7 months ago Marco Barbero #46

Starting from the example proposed over the precisionRound that I found on MDN (that event for 1.005 returs 1 and not 1.01), I write a custom precisionRound that manage a random precision number and for 1.005 returns 1.01.

This is the function:

``````function precisionRound(number, precision)
{
if(precision < 0)
{
var factor = Math.pow(10, precision);
return Math.round(number * factor) / factor;
}
else
return +(Math.round(number + "e+"+precision)  + "e-"+precision);
}

console.log(precisionRound(1234.5678, 1));  // output: 1234.6
console.log(precisionRound(1234.5678, -1)); // output: 1230
console.log(precisionRound(1.005, 2));      // output: 1.01
console.log(precisionRound(1.0005, 2));     // output: 1
console.log(precisionRound(1.0005, 3));     // output: 1.001
console.log(precisionRound(1.0005, 4));     // output: 1.0005
``````

For TypeScript:

``````public static precisionRound(number: number, precision: number)
{
if (precision < 0)
{
let factor = Math.pow(10, precision);
return Math.round(number * factor) / factor;
}
else
return +(Math.round(Number(number + "e+" + precision)) +
"e-" + precision);
}
``````

answered 7 months ago Amr Ali #47

In general, rounding is done by scaling: `round(num / p) * p`

Using the exponential notation handles rounding of +ve numbers, correctly. However, this method fails to round -ve edge cases correctly.

``````function round(num, precision = 2) {
var scaled = Math.round(num + "e" + precision);
return Number(scaled + "e" + -precision);
}

// testing some edge cases
console.log( round(1.005, 2) );  // 1.01 correct
console.log( round(2.175, 2) );  // 2.18 correct
console.log( round(5.015, 2) );  // 5.02 correct

console.log( round(-1.005, 2) );  // -1    wrong
console.log( round(-2.175, 2) );  // -2.17 wrong
console.log( round(-5.015, 2) );  // -5.01 wrong``````

Here, also is one function I wrote to do arithmetic rounding correctly. You can test it yourself.

``````/**
* MidpointRounding away from zero ('arithmetic' rounding)
* Uses a half-epsilon for correction. (This offsets IEEE-754
* half-to-even rounding that was applied at the edge cases).
*/

function RoundCorrect(num, precision = 2) {
// half epsilon to correct edge cases.
var c = 0.5 * Number.EPSILON * num;
//	var p = Math.pow(10, precision); //slow
var p = 1; while (precision--> 0) p *= 10;
if (num < 0)
p *= -1;
return Math.round((num + c) * p) / p;
}

// testing some edge cases
console.log(RoundCorrect(1.005, 2));  // 1.01 correct
console.log(RoundCorrect(2.175, 2));  // 2.18 correct
console.log(RoundCorrect(5.015, 2));  // 5.02 correct

console.log(RoundCorrect(-1.005, 2));  // -1.01 correct
console.log(RoundCorrect(-2.175, 2));  // -2.18 correct
console.log(RoundCorrect(-5.015, 2));  // -5.02 correct``````

answered 7 months ago Simon Prickett #48

In the node environment I just use the roundTo module:

``````const roundTo = require('round-to');
...
roundTo(123.4567, 2);

// 123.46
``````

answered 6 months ago Neil Meyer #49

# You can count the length of digits after the decimal and with a simple if statement set the type of rounding you want.

``````let numbers = 5.1356;

const countingDecimals = (numbers) => {
let decimal = numbers.toString().split(".").length;
return decimal;
}

if (countingDecimals(numbers) === 0) {
let localNumbers = numbers;
localNumbers = Math.Floor(localNumbers);
console.log(localNumbers);
} else if (countingDecimals(numbers) === 1) {
let localNumbers = numbers;
localNumbers = Math.round(localNumbers * 10) / 10
console.log(localNumbers);
} else {
let localNumbers = numbers;
localNumbers = Math.round(localNumbers * 100) / 100;
console.log(localNumbers); }``````

answered 6 months ago Arulraj #50

Use something like this "parseFloat(parseFloat(value).toFixed(2))"

``````parseFloat(parseFloat("1.7777777").toFixed(2))-->1.78
parseFloat(parseFloat("10").toFixed(2))-->10
parseFloat(parseFloat("9.1").toFixed(2))-->9.1
``````

answered 5 months ago VicJordan #51

For me Math.round() was not giving correct answer. I found toFixed(2) works better. Below are examples of both:

``````console.log(Math.round(43000 / 80000) * 100); // wrong answer

console.log(((43000 / 80000) * 100).toFixed(2)); // correct answer``````

answered 4 months ago OZZIE #52

From the existing answers I found another solution which seems to work great, which also works with sending in a string and eliminates trailing zeros.

``````function roundToDecimal(string, decimals) {
return parseFloat(parseFloat(string).toFixed(decimals));
}
``````

It doesn't take in to account if you send in some bull.. like "apa" though. Or it will probably throw an error which I think is the proper way anyway, it's never good to hide errors that should be fixed (by the calling function).

answered 3 months ago Roman M #53

Using Brian Ustas's solution:

``````function roundDecimal(value, precision) {
var multiplier = Math.pow(10, precision);
return Math.round(value * multiplier) / multiplier;
}
``````

answered 3 months ago Ross #54

This did the trick for me (TypeScript):

``````round(decimal: number, decimalPoints: number): number{
let roundedValue = Math.round(decimal * Math.pow(10, decimalPoints)) / Math.pow(10, decimalPoints);

console.log(`Rounded \${decimal} to \${roundedValue}`);
return roundedValue;
}

// Sample output:
Rounded 18.339840000000436 to 18.34
Rounded 52.48283999999984 to 52.48
Rounded 57.24612000000036 to 57.25
Rounded 23.068320000000142 to 23.07
Rounded 7.792980000000398 to 7.79
Rounded 31.54157999999981 to 31.54
Rounded 36.79686000000004 to 36.8
Rounded 34.723080000000124 to 34.72
Rounded 8.4375 to 8.44
Rounded 15.666960000000074 to 15.67
Rounded 29.531279999999924 to 29.53
Rounded 8.277420000000006 to 8.28
``````

answered 2 months ago Denis S Dujota #55

I was building a simple tipCalculator and there was a lot of answers here that seem to overcomplicate the issue. So I found summarizing the issue to be the best way to truly answer this question

if you want to create a rounded decimal number, first you call `toFixed(# of decimal places you want to keep)` and then wrap that in a Number()

so end result:

``````let amountDue = 286.44;
tip = Number((amountDue * 0.2).toFixed(2));
console.log(tip)  // 57.29 instead of 57.288
``````

answered 2 months ago Jinxer Albatross #56

Simple solution would be use lodash's ceil function if you want to round up...

https://lodash.com/docs/4.17.10#ceil

``````_.round(6.001,2)
``````

gives 6

``````_.ceil(6.001, 2);
``````

gives 6.01

``````_.ceil(37.4929,2);
``````

gives 37.5

``````_.round(37.4929,2);
``````

gives 37.49

answered 2 months ago Dmytro Medvid #57

The rounding problem can be avoided by using numbers represented in exponential notation.

``````public static roundFinancial(amount: number, decimals: number) {
return Number(Math.round(Number(`\${amount}e\${decimals}`)) + `e-\${decimals}`);
}
``````

answered 1 month ago aleha #58

``````var precalculatedPrecisions = [1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10];

function round(num, _prec) {
_precision = precalculatedPrecisions[_prec]
return Math.round(num * _precision + 1e-14) / _precision ;
}
``````

answered 2 weeks ago thecoolestname36 #59

This worked pretty well for me when wanting to always round up to a certain decimal. The key here is that we will always be rounding up with the Math.ceil function.

You could conditionally select ceil or floor if needed.

``````     /**
* Possibility to lose precision at large numbers
* @param number
* @returns Number number
*/
var roundUpToNearestHundredth = function(number) {

// Ensure that we use high precision Number
number = Number(number);

// Save the original number so when we extract the Hundredth decimal place we don't bit switch or lose precision
var numberSave = Number(number.toFixed(0));

// Remove the "integer" values off the top of the number
number = number - numberSave;

// Get the Hundredth decimal places
number *= 100;

// Ceil the decimals.  Therefore .15000001 will equal .151, etc.
number = Math.ceil(number);

// Put the decimals back into their correct spot
number /= 100;

// Add the "integer" back onto the number
return number + numberSave;

};

console.log(roundUpToNearestHundredth(6132423.1200000000001))``````