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

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.

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?

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
```

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, andsbe integers such thatk≥ 1, 10^{k-1}≤s< 10^{k}, the Number value fors× 10^{n-k}ism, andkis as small as possible. Note that k is the number of digits in the decimal representation ofs, thatsis not divisible by 10, and that the least significant digit ofsis 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://.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://.com/a/38676273/1709587. You may want to consider using the
* roundStringNumberWithoutTrailingZeroes function there instead.
*
* @param {number} num
* @param {number} dp
* @return {number}
*/
function roundFloatNumberWithoutTrailingZeroes (num, dp) {
var numToFixedDp = Number(num).toFixed(dp);
return Number(numToFixedDp);
}
```

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');
});
})
```

**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;
```

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*.

This may help you:

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

for more information, you can have a look at this link

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

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
```

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.

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);
}
```

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

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

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
```

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);
```

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,'');
```

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

In your case, the answer is:

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