Asked 2023-09-20 20:13:10 View
250,269

I'd like to round at most two 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?

- const formattedNumber = Math.round(myNumber * 100) / 100; - anyone
`const myNumber = 1.275; const formattedNumber = new Intl.NumberFormat('en', { minimumFractionDigits: 2, maximumFractionDigits: 2 }).format(myNumber); const formattedNumberInNumber = parseFloat(formattedNumber);`

// #=> 1.28. more - anyone

Use `Math.round()`

:

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

Or to be more specific and to ensure things like 1.005 round correctly, use Number.EPSILON :

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

Answered 2023-09-20 20:13:10

- @PSatishPatro (I assume you meant to say 224.99 and not 224.95). if you're rounding to the 2nd decimal (hundredths) then we should only care about what number the 3rd (thousandth) decimal is and everything after that is dropped. So from the input 224.98499999, only 224.984 matters which means
**224.98**is correct. - anyone - Math.round(1.255 * 100) / 100 will be 1.25 . it's wrong - anyone
- @PSatishPatro we're off-topic, I realise, but rounding 224.9849... to two decimal places should, in any language or by hand, result in 224.98. If you get 224.99 I'm afraid you did it wrong. The simplest way to think of it is that you're looking for the nearest number with only two decimal places. While there isn't much difference, 224.9849 is closer to 224.98 than to 224.99. - anyone
- I find that it rounds wrong for 10.075. Gives 10.07 rather than 10.08, even with the epsilon fix. - anyone
- Math.round((519.805+ Number.EPSILON) * 100) / 100, it rounds to 519.8 - anyone

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 * 100)/100 // Returns 1 instead of expected 1.01!
```

toFixed() will also * 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);
}
}
```

It is also at Plunker.

* Note:* This is not a universal solution for everyone. There are several different rounding algorithms. Your implementation can be different, and it depends on your requirements. See also

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

Another possible solution, which is not a bulletproof either.

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

In some cases, when you round a number like 1.3549999999999998, it will return an incorrect result. It should be 1.35, but the result is 1.36.

Answered 2023-09-20 20:13:10

- in this function
`roundNumberV2`

there is this condition`if (Math.pow(0.1, scale) > num) { return 0; }`

. may I know what is the purpose of this condition ? - anyone - Performance should be a concern also, which could make this approach less desirable.
`Math.round()`

is*much*faster. jsbin.com/kikocecemu/edit?js,output - anyone - Note, as a heads-up for someone because this bit me, but if you want to do something like
`var a = parseFloat(1/3).toFixed(2);`

it doesn't seem to like it when you do`var c = a + someNumber;`

- it will treat it like you are trying to add a string (that new`a`

there) to a number (`someNumber`

). So probably would need to do`var c = eval(a) + someNumber;`

. - anyone - Instead of
`eval(a)`

you should use`Number(a)`

,`parseFloat(a)`

(which actually behave the same stackoverflow.com/a/11988612/16940). You can even just use`+a`

. I prefer`Number(a)`

. - anyone - same problem as Ustas' suggestion. 10.075 input = 10.07 output. No good. - anyone

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

```
function roundToTwo(num) {
return +(Math.round(num + "e+2") + "e-2");
}
console.log('1.005 => ', roundToTwo(1.005));
console.log('10 => ', roundToTwo(10));
console.log('1.7777777 => ', roundToTwo(1.7777777));
console.log('9.1 => ', roundToTwo(9.1));
console.log('1234.5678 => ', roundToTwo(1234.5678));
console.log('1.3549999999999998 => ', roundToTwo(1.3549999999999998));
console.log('10.075 => ', roundToTwo(10.075));
```

Answered 2023-09-20 20:13:10

- @Redsandro,
`+(val)`

is the coercion equivalent of using`Number(val)`

. Concatenating "e-2" to an number resulted in a string that needed to be converted back to a number. - anyone - Pass a number with e and it returns NaN e.g. 1.19e-7 - anyone
- This does not work well for negative numbers. - anyone
- However, if num is
`-2.9e-7`

, then`+(Math.round(num + "e+2") + "e-2")`

returns`NaN`

, which is not the desired reult. At least on Chrome 101 - anyone - In case of -1.005 => -1 (without decimals) - anyone

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 2023-09-20 20:13:10

- I find this standalone (no
`prototype`

extension) version (ES6) easy to read and straight forward:`round = (num, precision) => Number(Math.round(num + "e+" + precision) + "e-" + precision);`

- anyone - What if the input number is already in exponential form? You will get NaN - anyone
- I receive this error in this (Math.round(number + "e+" + places)) Argument of type 'string' is not assignable to parameter of type 'number' In Typescript - anyone
- to accomodate for very small and very large number which will be in exponential form automatically you can address that with toFixed. I.e.
`function round(val, decimals) { return +(Math.round(+(val.toFixed(decimals) + "e+" + decimals)) + "e-" + decimals); }`

- anyone - oh come on dont modify prototypes - anyone

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

**Naive implementation**

Using the following function with halfway numbers, you will get either the upper rounded value as expected, or the lower rounded value sometimes depending on the input.

This `inconsistency`

in rounding may introduce hard to detect bugs in the client code.

```
function naiveRound(num, decimalPlaces = 0) {
var p = Math.pow(10, decimalPlaces);
return Math.round(num * p) / p;
}
console.log( naiveRound(1.245, 2) ); // 1.25 correct (rounded as expected)
console.log( naiveRound(1.255, 2) ); // 1.25 incorrect (should be 1.26)
// testing edge cases
console.log( naiveRound(1.005, 2) ); // 1 incorrect (should be 1.01)
console.log( naiveRound(2.175, 2) ); // 2.17 incorrect (should be 2.18)
console.log( naiveRound(5.015, 2) ); // 5.01 incorrect (should be 5.02)
```

In order to determine whether a rounding operation involves a midpoint value, the Round function multiplies the original value to be rounded by 10 ** n, where n is the desired number of fractional digits in the return value, and then determines whether the remaining fractional portion of the value is greater than or equal to .5. This `"Exact Testing for Equality"`

with floating-point values are problematic because of the floating-point format's issues with binary representation and precision. This means that any fractional portion of a number that is slightly less than .5 (because of a loss of precision) will not be rounded upward.

In the previous example, `5.015`

is a midpoint value if it is to be rounded to two decimal places, the value of 5.015 * 100 is actually `501.49999999999994`

. Because .49999999999994 is less than .5, it is rounded down to 501 and finally the result is 5.01.

**Better implementations**

**Exponential notation**

By converting the number to a string in the exponential notation, positive numbers are rounded as expected. But, be aware that negative numbers round differently than positive numbers.

In fact, it performs what is basically equivalent to "round half up" as the rule, you will see that `round(-1.005, 2)`

evaluates to `-1`

even though `round(1.005, 2)`

evaluates to `1.01`

. The lodash _.round method uses this technique.

```
/**
* Round half up ('round half towards positive infinity')
* Negative numbers round differently than positive numbers.
*/
function round(num, decimalPlaces = 0) {
num = Math.round(num + "e" + decimalPlaces);
return Number(num + "e" + -decimalPlaces);
}
// test rounding of half
console.log( round(0.5) ); // 1
console.log( round(-0.5) ); // 0
// testing edge cases
console.log( round(1.005, 2) ); // 1.01
console.log( round(2.175, 2) ); // 2.18
console.log( round(5.015, 2) ); // 5.02
console.log( round(-1.005, 2) ); // -1
console.log( round(-2.175, 2) ); // -2.17
console.log( round(-5.015, 2) ); // -5.01
```

If you want the usual behavior when rounding negative numbers, you would need to convert negative numbers to positive before calling Math.round(), and then convert them back to negative numbers before returning.

```
// Round half away from zero
function round(num, decimalPlaces = 0) {
if (num < 0)
return -round(-num, decimalPlaces);
num = Math.round(num + "e" + decimalPlaces);
return Number(num + "e" + -decimalPlaces);
}
```

**Approximate rounding**

To correct the rounding problem shown in the previous `naiveRound`

example, we can define a custom rounding function that performs a "nearly equal" test to determine whether a fractional value is sufficiently close to a midpoint value to be subject to midpoint rounding.

```
// round half away from zero
function round(num, decimalPlaces = 0) {
if (num < 0)
return -round(-num, decimalPlaces);
var p = Math.pow(10, decimalPlaces);
var n = num * p;
var f = n - Math.floor(n);
var e = Number.EPSILON * n;
// Determine whether this fraction is a midpoint value.
return (f >= .5 - e) ? Math.ceil(n) / p : Math.floor(n) / p;
}
// test rounding of half
console.log( round(0.5) ); // 1
console.log( round(-0.5) ); // -1
// testing edge cases
console.log( round(1.005, 2) ); // 1.01
console.log( round(2.175, 2) ); // 2.18
console.log( round(5.015, 2) ); // 5.02
console.log( round(-1.005, 2) ); // -1.01
console.log( round(-2.175, 2) ); // -2.18
console.log( round(-5.015, 2) ); // -5.02
```

**Number.EPSILON**

There is a different purely mathematical technique to perform round-to-nearest (using "round half away from zero"), in which epsilon correction is applied before calling the rounding function.

Simply, we add the smallest possible float value (= 1.0 ulp; unit in the last place) to the product before rounding. This moves to the next representable float value, away from zero, thus it will offset the binary round-off error that may occur during the multiplication by `10 ** n`

.

```
/**
* Round half away from zero ('commercial' rounding)
* Uses correction to offset floating-point inaccuracies.
* Works symmetrically for positive and negative numbers.
*/
function round(num, decimalPlaces = 0) {
var p = Math.pow(10, decimalPlaces);
var n = (num * p) * (1 + Number.EPSILON);
return Math.round(n) / p;
}
// rounding of half
console.log( round(0.5) ); // 1
console.log( round(-0.5) ); // -1
// testing edge cases
console.log( round(1.005, 2) ); // 1.01
console.log( round(2.175, 2) ); // 2.18
console.log( round(5.015, 2) ); // 5.02
console.log( round(-1.005, 2) ); // -1.01
console.log( round(-2.175, 2) ); // -2.18
console.log( round(-5.015, 2) ); // -5.02
```

After adding 1 ulp, the value of 5.015 * 100 which is `501.49999999999994`

will be corrected to `501.50000000000006`

, this will rounded up to 502 and finally the result is 5.02.

Note that the size of a unit in last place ("ulp") is determined by (1) the magnitude of the number and (2) the relative machine epsilon (2^-52). Ulps are relatively larger at numbers with bigger magnitudes than they are at numbers with smaller magnitudes.

**Double rounding**

Here, we use the `toPrecision()`

method to strip the floating-point round-off errors in the intermediate calculations. Simply, we round to 15 significant figures to strip the round-off error at the 16th significant digit. This technique to preround the result to significant digits is also used by **PHP 7** `round`

function.

The value of 5.015 * 100 which is `501.49999999999994`

will be rounded first to 15 significant digits as `501.500000000000`

, then it will rounded up again to 502 and finally the result is 5.02.

```
// Round half away from zero
function round(num, decimalPlaces = 0) {
if (num < 0)
return -round(-num, decimalPlaces);
var p = Math.pow(10, decimalPlaces);
var n = (num * p).toPrecision(15);
return Math.round(n) / p;
}
// rounding of half
console.log( round(0.5) ); // 1
console.log( round(-0.5) ); // -1
// testing edge cases
console.log( round(1.005, 2) ); // 1.01
console.log( round(2.175, 2) ); // 2.18
console.log( round(5.015, 2) ); // 5.02
console.log( round(-1.005, 2) ); // -1.01
console.log( round(-2.175, 2) ); // -2.18
console.log( round(-5.015, 2) ); // -5.02
```

**Arbitrary-precision JavaScript library** - decimal.js

```
// Round half away from zero
function round(num, decimalPlaces = 0) {
return new Decimal(num).toDecimalPlaces(decimalPlaces).toNumber();
}
// rounding of half
console.log( round(0.5) ); // 1
console.log( round(-0.5) ); // -1
// testing edge cases
console.log( round(1.005, 2) ); // 1.01
console.log( round(2.175, 2) ); // 2.18
console.log( round(5.015, 2) ); // 5.02
console.log( round(-1.005, 2) ); // -1.01
console.log( round(-2.175, 2) ); // -2.18
console.log( round(-5.015, 2) ); // -5.02
```

`<script src="https://cdnjs.cloudflare.com/ajax/libs/decimal.js/10.2.1/decimal.js" integrity="sha512-GKse2KVGCCMVBn4riigHjXE8j5hCxYLPXDw8AvcjUtrt+a9TbZFtIKGdArXwYOlZvdmkhQLWQ46ZE3Q1RIa7uQ==" crossorigin="anonymous"></script>`

**Solution 1: string in exponential notation**

Inspired by the solution provided by KFish here: https://stackoverflow.com/a/55521592/4208440

A simple drop in solution that provides accurate decimal rounding, flooring, and ceiling to a specific number of decimal places without adding a whole library. It treats floats more like decimals by fixing the binary rounding issues to avoid unexpected results: for example, floor((0.1+0.7)*10) will return the expected result 8.

Numbers are rounded to a specific number of fractional digits. Specifying a negative precision will round to any number of places to the left of the decimal point.

```
// Solution 1
var DecimalPrecision = (function() {
if (Math.trunc === undefined) {
Math.trunc = function(v) {
return v < 0 ? Math.ceil(v) : Math.floor(v);
};
}
var decimalAdjust = function myself(type, num, decimalPlaces) {
if (type === 'round' && num < 0)
return -myself(type, -num, decimalPlaces);
var shift = function(value, exponent) {
value = (value + 'e').split('e');
return +(value[0] + 'e' + (+value[1] + (exponent || 0)));
};
var n = shift(num, +decimalPlaces);
return shift(Math[type](n), -decimalPlaces);
};
return {
// Decimal round (half away from zero)
round: function(num, decimalPlaces) {
return decimalAdjust('round', num, decimalPlaces);
},
// Decimal ceil
ceil: function(num, decimalPlaces) {
return decimalAdjust('ceil', num, decimalPlaces);
},
// Decimal floor
floor: function(num, decimalPlaces) {
return decimalAdjust('floor', num, decimalPlaces);
},
// Decimal trunc
trunc: function(num, decimalPlaces) {
return decimalAdjust('trunc', num, decimalPlaces);
},
// Format using fixed-point notation
toFixed: function(num, decimalPlaces) {
return decimalAdjust('round', num, decimalPlaces).toFixed(decimalPlaces);
}
};
})();
// test rounding of half
console.log(DecimalPrecision.round(0.5)); // 1
console.log(DecimalPrecision.round(-0.5)); // -1
// testing very small numbers
console.log(DecimalPrecision.ceil(1e-8, 2) === 0.01);
console.log(DecimalPrecision.floor(1e-8, 2) === 0);
// testing simple cases
console.log(DecimalPrecision.round(5.12, 1) === 5.1);
console.log(DecimalPrecision.round(-5.12, 1) === -5.1);
console.log(DecimalPrecision.ceil(5.12, 1) === 5.2);
console.log(DecimalPrecision.ceil(-5.12, 1) === -5.1);
console.log(DecimalPrecision.floor(5.12, 1) === 5.1);
console.log(DecimalPrecision.floor(-5.12, 1) === -5.2);
console.log(DecimalPrecision.trunc(5.12, 1) === 5.1);
console.log(DecimalPrecision.trunc(-5.12, 1) === -5.1);
// testing edge cases for round
console.log(DecimalPrecision.round(1.005, 2) === 1.01);
console.log(DecimalPrecision.round(39.425, 2) === 39.43);
console.log(DecimalPrecision.round(-1.005, 2) === -1.01);
console.log(DecimalPrecision.round(-39.425, 2) === -39.43);
// testing edge cases for ceil
console.log(DecimalPrecision.ceil(9.13, 2) === 9.13);
console.log(DecimalPrecision.ceil(65.18, 2) === 65.18);
console.log(DecimalPrecision.ceil(-2.26, 2) === -2.26);
console.log(DecimalPrecision.ceil(-18.15, 2) === -18.15);
// testing edge cases for floor
console.log(DecimalPrecision.floor(2.26, 2) === 2.26);
console.log(DecimalPrecision.floor(18.15, 2) === 18.15);
console.log(DecimalPrecision.floor(-9.13, 2) === -9.13);
console.log(DecimalPrecision.floor(-65.18, 2) === -65.18);
// testing edge cases for trunc
console.log(DecimalPrecision.trunc(2.26, 2) === 2.26);
console.log(DecimalPrecision.trunc(18.15, 2) === 18.15);
console.log(DecimalPrecision.trunc(-2.26, 2) === -2.26);
console.log(DecimalPrecision.trunc(-18.15, 2) === -18.15);
// testing round to tens and hundreds
console.log(DecimalPrecision.round(1262.48, -1) === 1260);
console.log(DecimalPrecision.round(1262.48, -2) === 1300);
// testing toFixed()
console.log(DecimalPrecision.toFixed(1.005, 2) === "1.01");
```

**Solution 2: purely mathematical ( Number.EPSILON)**

This solution avoids any string conversion / manipulation of any kind for performance reasons.

```
// Solution 2
var DecimalPrecision2 = (function() {
if (Number.EPSILON === undefined) {
Number.EPSILON = Math.pow(2, -52);
}
if (Math.sign === undefined) {
Math.sign = function(x) {
return ((x > 0) - (x < 0)) || +x;
};
}
return {
// Decimal round (half away from zero)
round: function(num, decimalPlaces) {
var p = Math.pow(10, decimalPlaces || 0);
var n = (num * p) * (1 + Number.EPSILON);
return Math.round(n) / p;
},
// Decimal ceil
ceil: function(num, decimalPlaces) {
var p = Math.pow(10, decimalPlaces || 0);
var n = (num * p) * (1 - Math.sign(num) * Number.EPSILON);
return Math.ceil(n) / p;
},
// Decimal floor
floor: function(num, decimalPlaces) {
var p = Math.pow(10, decimalPlaces || 0);
var n = (num * p) * (1 + Math.sign(num) * Number.EPSILON);
return Math.floor(n) / p;
},
// Decimal trunc
trunc: function(num, decimalPlaces) {
return (num < 0 ? this.ceil : this.floor)(num, decimalPlaces);
},
// Format using fixed-point notation
toFixed: function(num, decimalPlaces) {
return this.round(num, decimalPlaces).toFixed(decimalPlaces);
}
};
})();
// test rounding of half
console.log(DecimalPrecision2.round(0.5)); // 1
console.log(DecimalPrecision2.round(-0.5)); // -1
// testing very small numbers
console.log(DecimalPrecision2.ceil(1e-8, 2) === 0.01);
console.log(DecimalPrecision2.floor(1e-8, 2) === 0);
// testing simple cases
console.log(DecimalPrecision2.round(5.12, 1) === 5.1);
console.log(DecimalPrecision2.round(-5.12, 1) === -5.1);
console.log(DecimalPrecision2.ceil(5.12, 1) === 5.2);
console.log(DecimalPrecision2.ceil(-5.12, 1) === -5.1);
console.log(DecimalPrecision2.floor(5.12, 1) === 5.1);
console.log(DecimalPrecision2.floor(-5.12, 1) === -5.2);
console.log(DecimalPrecision2.trunc(5.12, 1) === 5.1);
console.log(DecimalPrecision2.trunc(-5.12, 1) === -5.1);
// testing edge cases for round
console.log(DecimalPrecision2.round(1.005, 2) === 1.01);
console.log(DecimalPrecision2.round(39.425, 2) === 39.43);
console.log(DecimalPrecision2.round(-1.005, 2) === -1.01);
console.log(DecimalPrecision2.round(-39.425, 2) === -39.43);
// testing edge cases for ceil
console.log(DecimalPrecision2.ceil(9.13, 2) === 9.13);
console.log(DecimalPrecision2.ceil(65.18, 2) === 65.18);
console.log(DecimalPrecision2.ceil(-2.26, 2) === -2.26);
console.log(DecimalPrecision2.ceil(-18.15, 2) === -18.15);
// testing edge cases for floor
console.log(DecimalPrecision2.floor(2.26, 2) === 2.26);
console.log(DecimalPrecision2.floor(18.15, 2) === 18.15);
console.log(DecimalPrecision2.floor(-9.13, 2) === -9.13);
console.log(DecimalPrecision2.floor(-65.18, 2) === -65.18);
// testing edge cases for trunc
console.log(DecimalPrecision2.trunc(2.26, 2) === 2.26);
console.log(DecimalPrecision2.trunc(18.15, 2) === 18.15);
console.log(DecimalPrecision2.trunc(-2.26, 2) === -2.26);
console.log(DecimalPrecision2.trunc(-18.15, 2) === -18.15);
// testing round to tens and hundreds
console.log(DecimalPrecision2.round(1262.48, -1) === 1260);
console.log(DecimalPrecision2.round(1262.48, -2) === 1300);
// testing toFixed()
console.log(DecimalPrecision2.toFixed(1.005, 2) === "1.01");
```

**Solution 3: double rounding**

This solution uses the `toPrecision()`

method to strip the floating-point round-off errors.

```
// Solution 3
var DecimalPrecision3 = (function() {
if (Math.trunc === undefined) {
Math.trunc = function(v) {
return v < 0 ? Math.ceil(v) : Math.floor(v);
};
}
var powers = [
1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7,
1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22
];
var intpow10 = function(power) {
/* Not in lookup table */
if (power < 0 || power > 22) {
return Math.pow(10, power);
}
return powers[power];
};
// Eliminate binary floating-point inaccuracies.
var stripError = function(num) {
if (Number.isInteger(num))
return num;
return parseFloat(num.toPrecision(15));
};
var decimalAdjust = function myself(type, num, decimalPlaces) {
if (type === 'round' && num < 0)
return -myself(type, -num, decimalPlaces);
var p = intpow10(decimalPlaces || 0);
var n = stripError(num * p);
return Math[type](n) / p;
};
return {
// Decimal round (half away from zero)
round: function(num, decimalPlaces) {
return decimalAdjust('round', num, decimalPlaces);
},
// Decimal ceil
ceil: function(num, decimalPlaces) {
return decimalAdjust('ceil', num, decimalPlaces);
},
// Decimal floor
floor: function(num, decimalPlaces) {
return decimalAdjust('floor', num, decimalPlaces);
},
// Decimal trunc
trunc: function(num, decimalPlaces) {
return decimalAdjust('trunc', num, decimalPlaces);
},
// Format using fixed-point notation
toFixed: function(num, decimalPlaces) {
return decimalAdjust('round', num, decimalPlaces).toFixed(decimalPlaces);
}
};
})();
// test rounding of half
console.log(DecimalPrecision3.round(0.5)); // 1
console.log(DecimalPrecision3.round(-0.5)); // -1
// testing very small numbers
console.log(DecimalPrecision3.ceil(1e-8, 2) === 0.01);
console.log(DecimalPrecision3.floor(1e-8, 2) === 0);
// testing simple cases
console.log(DecimalPrecision3.round(5.12, 1) === 5.1);
console.log(DecimalPrecision3.round(-5.12, 1) === -5.1);
console.log(DecimalPrecision3.ceil(5.12, 1) === 5.2);
console.log(DecimalPrecision3.ceil(-5.12, 1) === -5.1);
console.log(DecimalPrecision3.floor(5.12, 1) === 5.1);
console.log(DecimalPrecision3.floor(-5.12, 1) === -5.2);
console.log(DecimalPrecision3.trunc(5.12, 1) === 5.1);
console.log(DecimalPrecision3.trunc(-5.12, 1) === -5.1);
// testing edge cases for round
console.log(DecimalPrecision3.round(1.005, 2) === 1.01);
console.log(DecimalPrecision3.round(39.425, 2) === 39.43);
console.log(DecimalPrecision3.round(-1.005, 2) === -1.01);
console.log(DecimalPrecision3.round(-39.425, 2) === -39.43);
// testing edge cases for ceil
console.log(DecimalPrecision3.ceil(9.13, 2) === 9.13);
console.log(DecimalPrecision3.ceil(65.18, 2) === 65.18);
console.log(DecimalPrecision3.ceil(-2.26, 2) === -2.26);
console.log(DecimalPrecision3.ceil(-18.15, 2) === -18.15);
// testing edge cases for floor
console.log(DecimalPrecision3.floor(2.26, 2) === 2.26);
console.log(DecimalPrecision3.floor(18.15, 2) === 18.15);
console.log(DecimalPrecision3.floor(-9.13, 2) === -9.13);
console.log(DecimalPrecision3.floor(-65.18, 2) === -65.18);
// testing edge cases for trunc
console.log(DecimalPrecision3.trunc(2.26, 2) === 2.26);
console.log(DecimalPrecision3.trunc(18.15, 2) === 18.15);
console.log(DecimalPrecision3.trunc(-2.26, 2) === -2.26);
console.log(DecimalPrecision3.trunc(-18.15, 2) === -18.15);
// testing round to tens and hundreds
console.log(DecimalPrecision3.round(1262.48, -1) === 1260);
console.log(DecimalPrecision3.round(1262.48, -2) === 1300);
// testing toFixed()
console.log(DecimalPrecision3.toFixed(1.005, 2) === "1.01");
```

**Solution 4: double rounding v2**

This solution is just like Solution 3, however it uses a custom `toPrecision()`

function.

```
// Solution 4
var DecimalPrecision4 = (function() {
if (Math.trunc === undefined) {
Math.trunc = function(v) {
return v < 0 ? Math.ceil(v) : Math.floor(v);
};
}
var powers = [
1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7,
1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22
];
var intpow10 = function(power) {
/* Not in lookup table */
if (power < 0 || power > 22) {
return Math.pow(10, power);
}
return powers[power];
};
var toPrecision = function(num, significantDigits) {
// Return early for ±0, NaN and Infinity.
if (!num || !Number.isFinite(num))
return num;
// Compute shift of the decimal point (sf - leftSidedDigits).
var shift = significantDigits - 1 - Math.floor(Math.log10(Math.abs(num)));
// Return if rounding to the same or higher precision.
var decimalPlaces = 0;
for (var p = 1; num != Math.round(num * p) / p; p *= 10) decimalPlaces++;
if (shift >= decimalPlaces)
return num;
// Round to "shift" fractional digits
var scale = intpow10(Math.abs(shift));
return shift > 0 ?
Math.round(num * scale) / scale :
Math.round(num / scale) * scale;
};
// Eliminate binary floating-point inaccuracies.
var stripError = function(num) {
if (Number.isInteger(num))
return num;
return toPrecision(num, 15);
};
var decimalAdjust = function myself(type, num, decimalPlaces) {
if (type === 'round' && num < 0)
return -myself(type, -num, decimalPlaces);
var p = intpow10(decimalPlaces || 0);
var n = stripError(num * p);
return Math[type](n) / p;
};
return {
// Decimal round (half away from zero)
round: function(num, decimalPlaces) {
return decimalAdjust('round', num, decimalPlaces);
},
// Decimal ceil
ceil: function(num, decimalPlaces) {
return decimalAdjust('ceil', num, decimalPlaces);
},
// Decimal floor
floor: function(num, decimalPlaces) {
return decimalAdjust('floor', num, decimalPlaces);
},
// Decimal trunc
trunc: function(num, decimalPlaces) {
return decimalAdjust('trunc', num, decimalPlaces);
},
// Format using fixed-point notation
toFixed: function(num, decimalPlaces) {
return decimalAdjust('round', num, decimalPlaces).toFixed(decimalPlaces);
}
};
})();
// test rounding of half
console.log(DecimalPrecision4.round(0.5)); // 1
console.log(DecimalPrecision4.round(-0.5)); // -1
// testing very small numbers
console.log(DecimalPrecision4.ceil(1e-8, 2) === 0.01);
console.log(DecimalPrecision4.floor(1e-8, 2) === 0);
// testing simple cases
console.log(DecimalPrecision4.round(5.12, 1) === 5.1);
console.log(DecimalPrecision4.round(-5.12, 1) === -5.1);
console.log(DecimalPrecision4.ceil(5.12, 1) === 5.2);
console.log(DecimalPrecision4.ceil(-5.12, 1) === -5.1);
console.log(DecimalPrecision4.floor(5.12, 1) === 5.1);
console.log(DecimalPrecision4.floor(-5.12, 1) === -5.2);
console.log(DecimalPrecision4.trunc(5.12, 1) === 5.1);
console.log(DecimalPrecision4.trunc(-5.12, 1) === -5.1);
// testing edge cases for round
console.log(DecimalPrecision4.round(1.005, 2) === 1.01);
console.log(DecimalPrecision4.round(39.425, 2) === 39.43);
console.log(DecimalPrecision4.round(-1.005, 2) === -1.01);
console.log(DecimalPrecision4.round(-39.425, 2) === -39.43);
// testing edge cases for ceil
console.log(DecimalPrecision4.ceil(9.13, 2) === 9.13);
console.log(DecimalPrecision4.ceil(65.18, 2) === 65.18);
console.log(DecimalPrecision4.ceil(-2.26, 2) === -2.26);
console.log(DecimalPrecision4.ceil(-18.15, 2) === -18.15);
// testing edge cases for floor
console.log(DecimalPrecision4.floor(2.26, 2) === 2.26);
console.log(DecimalPrecision4.floor(18.15, 2) === 18.15);
console.log(DecimalPrecision4.floor(-9.13, 2) === -9.13);
console.log(DecimalPrecision4.floor(-65.18, 2) === -65.18);
// testing edge cases for trunc
console.log(DecimalPrecision4.trunc(2.26, 2) === 2.26);
console.log(DecimalPrecision4.trunc(18.15, 2) === 18.15);
console.log(DecimalPrecision4.trunc(-2.26, 2) === -2.26);
console.log(DecimalPrecision4.trunc(-18.15, 2) === -18.15);
// testing round to tens and hundreds
console.log(DecimalPrecision4.round(1262.48, -1) === 1260);
console.log(DecimalPrecision4.round(1262.48, -2) === 1300);
// testing toFixed()
console.log(DecimalPrecision4.toFixed(1.005, 2) === "1.01");
```

http://jsbench.github.io/#31ec3a8b3d22bd840f8e6822e681a3ac

Here is a benchmark comparing the operations per second in the solutions above on Chrome 109.0.0.0. Rounding functions using the `Number.EPSILON`

is at least 10x-20x faster. Obviously all browsers differ, so your mileage may vary.

Thanks @Mike for adding a screenshot of the benchmark.

Answered 2023-09-20 20:13:10

- Hey @AmrAli. This is an awesome answer. One of the few that are as accurate as possible. Thanks! 👍 I particularly like
`Solution 2`

for it's speed. One thing I noticed is the speed can be increased by ~5-10% if the early-return check for`isRound`

is removed. It adds more operations than just running the`decimalAdjust`

function. Returning early by using isRound actually takes longer. - anyone - I've looked through many solutions on StackOverflow and this one is the best. The Exponential notation solution with the mod for negative numbers seems to work best for currency and matches the Java round calculations on the backend. - anyone
- This answer is a very good example why you shouldn't just check the first comment in stackoverflow. Those 2 above are just simply wrong. - anyone
- Instead of providing a benchmark you should have run a test showing whether any of these techniques actually works, for say
*0.0001 < x < 0.9999*. You might get a surprise how many of them fail. Over 90%. - anyone - Posts like this show how silly JavaScipt can be, just to round a number. Why doesn't Math.round() accept a 2nd arg for the number of places to round like to like any sensible language? - anyone

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

**EDIT (2019):**

Like @maganap and some peoples have pointed out, it's best to add `Number.EPSILON`

before multiplying:

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

**EDIT (december 2019):**

Lately, I use a function similar to this one for comparing numbers epsilon-aware:

```
const ESPILON_RATE = 1 + Number.EPSILON ;
const ESPILON_ZERO = Number.MIN_VALUE ;
function epsilonEquals( a , b ) {
if ( Number.isNaN( a ) || Number.isNaN( b ) ) {
return false ;
}
if ( a === 0 || b === 0 ) {
return a <= b + EPSILON_ZERO && b <= a + EPSILON_ZERO ;
}
return a <= b * EPSILON_RATE && b <= a * EPSILON_RATE ;
}
```

My use-case is an assertion + data validation lib I'm developing for many years.

In fact, in the code I'm using `ESPILON_RATE = 1 + 4 * Number.EPSILON`

and `EPSILON_ZERO = 4 * Number.MIN_VALUE`

(four times the epsilon), because I want an equality checker loose enough for cumulating floating point error.

So far, it looks perfect for me. I hope it will help.

Answered 2023-09-20 20:13:10

- Should I use 1000 instead of 100 if I want to round to 3 decimal numbers? - anyone
- Math.round((224.98499999 * 100 + Number.EPSILON)) / 100 224.98 Instead of 224.99 - anyone
- @PSatishPatro That is correct. .849 is closer to .8 than it is to .9, thus, it's rounded down to .8. - anyone
- @RandomElephant, okay, but generally when we calculate we do rounding up which is rounding HALF UP from the last digit. 98499 -> .9849 -> .985 -> .99 .Is there any way to achieve this in js? - anyone
- @PSatishPatro There is, but it's incorrect math. There's no general rounding up where you start from the last digit, and if you do, you seriously need to consider re-learning maths. Edit: To answer, you'd take the length of the number digits, and looped them from the last one, rounding each one and changing the intial number until you got to the desired place count. - anyone

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://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;
}
if (num[0] == '-') {
return "-" + roundStringNumberWithoutTrailingZeroes(num.slice(1), dp)
}
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.
// We want to do this while still avoiding converting the whole
// beforePart to a Number (since that could cause loss of precision if
// beforePart is bigger than Number.MAX_SAFE_INTEGER), so the logic for
// this is once again kinda complicated.
// Note we can (and want to) use early returns here because the
// zero-stripping logic at the end of
// roundStringNumberWithoutTrailingZeroes does NOT apply here, since
// the result is a whole number.
if (/^9+$/.test(beforePoint)) {
return "1" + beforePoint.replaceAll("9", "0")
}
// Starting from the last digit, increment digits until we find one
// that is not 9, then stop
var i = beforePoint.length - 1;
while (true) {
if (beforePoint[i] == '9') {
beforePoint = beforePoint.substr(0, i) +
'0' +
beforePoint.substr(i+1);
i--;
} else {
beforePoint = beforePoint.substr(0, i) +
(Number(beforePoint[i]) + 1) +
beforePoint.substr(i+1);
break;
}
}
return beforePoint
} 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'
> *roundStringNumberWithoutTrailingZeroes('16.996', 2)*
'17'

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

Answered 2023-09-20 20:13:10

Consider `.toFixed()`

and `.toPrecision()`

:

Answered 2023-09-20 20:13:10

- In firefox,
`3.9935.toFixed(3) → "3.994"`

,`3.9945.toFixed(3) → "3.994"`

,`3.9955.toFixed(3) → "3.995"`

,`3.9965.toFixed(3) → "3.997"`

. Is it expected behavior? For example, shouldn't`3.9945.toFixed(3)`

return`"3.995"`

or`3.9955.toFixed(3)`

return`"3.996"`

? - anyone - A Kunin has told a bit about this at below answer. - anyone
- toFixed() sometimes doesn't round correctly. I've seen it myself. Math.round is better - anyone

One can use `.toFixed(NumberOfDecimalPlaces)`

.

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

Answered 2023-09-20 20:13:10

- This is a duplicate of user3711536's answer—though equally without any explanation whatsoever or link to documentation. At least the other answer had more sample input and output. - anyone
- does not trim zeros - anyone

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 2023-09-20 20:13:10

- Here's a brief video tutorial how to round to 2 decimal in js Wouldn't it be easier to just use the built-in toFixed(N) method? - anyone

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

To round up, use this:

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

Answered 2023-09-20 20:13:10

- 1.3549999999999998 will return incorrect result. Should be 1.35 but result is 1.36. - anyone
- Most values will return an incorrect result. Try it. - anyone
- I would say that 1.36 is actually the correct answer, if you want to always round up at the second decimal place (which is what the OP wants, I believe) - anyone

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.
*/
function decimalAdjust(type, value, exp) {
// 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) {
return decimalAdjust('round', value, exp);
};
}
// Decimal floor
if (!Math.floor10) {
Math.floor10 = function(value, exp) {
return decimalAdjust('floor', value, exp);
};
}
// Decimal ceil
if (!Math.ceil10) {
Math.ceil10 = function(value, exp) {
return decimalAdjust('ceil', 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 2023-09-20 20:13:10

This may help you:

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

For more information, you can have a look at *Math.round(num) vs num.toFixed(0) and browser inconsistencies*

Answered 2023-09-20 20:13:10

- Why in the world does the accepted answer have so many more votes than this one since they're practically the same thing, but this one was posted 1 minute after the accepted one? - anyone
- Math.round(1.965 * 100) / 100 will be 1.96 . it's wrong. - anyone
- They were roughly identical when created. The first substantial edit of the accepted answer was in 2020, while this answer was edited to include extra information 9 minutes after posted. So if this answer was wrong at creation, the accepted answer was wrong for the next 8 years. - anyone

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

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

For example:

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

Answered 2023-09-20 20:13:10

- @Peter The set of functionalities that Lodash provide is really good compared to standard Javascript. However, I heard that Lodash has some performance issue with compare to standard JS. codeburst.io/… - anyone
- I accept your point that there are performance drawbacks with using lodash. I think that those issues are common to many abstractions. But just look at how many answers there are on this thread and how the intuitive solutions fail for edge cases. We have seen this pattern with jQuery and the root problem was solved when browsers adopted a common standard that solved most of our use cases. Performance bottlenecks were then moved to the browser engines. I think the same should happen to lodash. :) - anyone

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 2023-09-20 20:13:10

- Important to note that toFixed does not perform a rounding, and that Math.round just rounds to the nearest whole number. To preserve the decimals we therefore need to multiply the original number by the number of powers of ten whose zeros representing your desired number of decimals, and then divide the result by the same number. In your case: Math.round(43000 / 80000 * 100 * 100) / 100. At last toFixed(2) may be applied in order to ensure that there is always two decimals in the result (with trailing zeros where needed) – perfect for right-aligning a series of numbers presented vertically :) - anyone

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

Answered 2023-09-20 20:13:10

- Wrap it all in
`Number`

again, if you don't want it returned as a string:`Number(Number(x).toFixed(2));`

- anyone - The
`Number`

call is not necessary,`x.toFixed(2)`

works. - anyone - @bgusach Number call needed, since the statement x.toFixed(2) return string and not a number. To convert again to number we need to wrap with Number - anyone
- When using this method
`(1).toFixed(2)`

returns`1.00`

, but questioner needed`1`

in this case. - anyone - This doesn't work,
`1.005.toFixed(2)`

yields`"1"`

when it should be`"1.01"`

. - anyone

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

Answered 2023-09-20 20:13:10

- An explanation would be in order. E.g., what is the idea/gist? Why is toFixed() all there is to it? Is it from a particular library? What version of JavaScript/when was it introduced? From the Help Center:
*"...always explain why the solution you're presenting is appropriate and how it works"*. Please respond by editing (changing) your answer, not here in comments ("Edit:", "Update:", or similar - the answer should appear as if it was written today). - anyone*without* - OK, the OP has left the building. Perhaps someone else can chime in? - anyone

Try this *lightweight* solution:

```
function round(x, digits){
return parseFloat(x.toFixed(digits))
}
round(1.222, 2);
// 1.22
round(1.222, 10);
// 1.222
```

Answered 2023-09-20 20:13:10

- Anyone know if there's any difference between this and
`return Number(x.toFixed(digits))`

? - anyone - @JoeRocc ... should make no difference as far a I can see since
`.toFixed()`

allows only for numbers anyways . - anyone - This answer has the same problem as mentioned several times on this page. Try
`round(1.005, 2)`

and see a result of`1`

instead of`1.01`

. - anyone - seems more a problem of the rounding algo? - there are more than one would imagine: en.wikipedia.org/wiki/Rounding ...
`round(0.995, 2) => 0.99`

;`round(1.006, 2) => 1.01`

;`round(1.005, 2) => 1`

- anyone - This works, but it adds unnecessary complexity to the system as converts a float into a string and then parses the string back to a float. - anyone

There are a couple of ways to do that. For people like me, 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 the proper `round`

method in the libraries.

Answered 2023-09-20 20:13:10

- The second option will return a string with exactly two decimal points. The question asks for decimal points only if necessary. The first option is better in this case. - anyone
- @MarcosLima
`Number.toFixed()`

will return a string but with a plus symbol before it, JS interpreter will convert the string to a number. This is a syntax sugar. - anyone - On Firefox,
`alert((+1234).toFixed(2))`

shows "1234.00". - anyone - On Firefox,
`alert(+1234.toFixed(2))`

throws`SyntaxError: identifier starts immediately after numeric literal`

. I stick with the 1st option. - anyone - This doesn't work in some edge cases: try (jsfiddle) with
`362.42499999999995`

. Expected result (as in PHP`echo round(362.42499999999995, 2)`

):`362.43`

. Actual result:`362.42`

- anyone

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 2023-09-20 20:13:10

- The toFixed method returns a string. If you want a number result you'll need to send the result of toFixed to parseFloat. - anyone
- @Zambonilli Or just multiply by 1 if it necessary. but because fixed number most cases are for display and not for calculation string is the right format - anyone
- -1; not only was
`toFixed`

suggested by multiple answers years before yours, but it fails to satisfy the "only if necessary" condition in the question;`(1).toFixed(2)`

gives`"1.00"`

where the asker desired`"1"`

. - anyone - Ok got it. I add some solution also for that case - anyone
- If you're using lodash, it's even easier: _.round(number, decimalPlace) Deleted my last comment, cuz it has an issue. Lodash _.round DOES work, though. 1.005 with decimal place of 2 converts to 1.01. - anyone

Another simple solution (without writing any function) may to use toFixed() and then convert to float again:

For example:

```
var objNumber = 1201203.1256546456;
objNumber = parseFloat(objNumber.toFixed(2))
```

Answered 2023-09-20 20:13:10

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

then you can just `parseFloat`

and zeroes will 'go away'.

```
console.log(parseFloat((1.4999).toPrecision(3)));
console.log(parseFloat((1.005).toPrecision(3)));
console.log(parseFloat((1.0051).toPrecision(3)));
```

It doesn't solve the '1.005 rounding problem' though - since it is intrinsic to how float fractions are being processed.

`console.log(1.005 - 0.005);`

If you are open to libraries you can use bignumber.js

```
console.log(1.005 - 0.005);
console.log(new BigNumber(1.005).minus(0.005));
console.log(new BigNumber(1.005).round(4));
console.log(new BigNumber(1.005).round(3));
console.log(new BigNumber(1.005).round(2));
console.log(new BigNumber(1.005).round(1));
```

`<script src="https://cdnjs.cloudflare.com/ajax/libs/bignumber.js/2.3.0/bignumber.min.js"></script>`

Answered 2023-09-20 20:13:10

`(1.005).toPrecision(3)`

still returns`1.00`

instead of`1.01`

actually. - anyone`toPrecision`

returns a string which changes the desired output type. - anyone- @Giacomo It is not a flaw of
`.toPrecision`

method, it is a specificity of floating-point numbers (which numbers in JS are) — try`1.005 - 0.005`

, it will return`0.9999999999999999`

. - anyone `(1).toPrecision(3)`

returns '1.00', but questioner wanted to have`1`

in this case. - anyone- As @Giacomo said, this answer seems to confuse "significant digits" with "rounding to a number of decimal places".
`toPrecision`

does the format, not the latter, and is not an answer to the OP's question, although it may seem at first relevant it gets a lot wrong. See en.wikipedia.org/wiki/Significant_figures. For example`Number(123.4).toPrecision(2)`

returns`"1.2e+2"`

and`Number(12.345).toPrecision(2)`

returns`"12"`

. I'd also agree with @adamduren's point that it returns a string which is not desirable (not a huge problem but not desirable). - anyone

The easiest approach would be to use toFixed and then strip trailing zeros using the Number function:

```
const number = 15.5;
Number(number.toFixed(2)); // 15.5
```

```
const number = 1.7777777;
Number(number.toFixed(2)); // 1.78
```

Answered 2023-09-20 20:13:10

- this does not work for all cases. do extensive tests before posting answers. - anyone
- @baburao Please post a case in which the above solution doesn't work - anyone
- const number = 15; Number(number.toFixed(2)); //15.00 instead of 15 - anyone
- @KevinJhangiani const number = 15; Number(number.toFixed(2)); // 15 - I tested it both on newest Chrome and Firefox - anyone
- The commenters are totally right, and I realized the error in my code after posting that! - anyone

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 2023-09-20 20:13:10

- This is the cleanest solution there is by far and sidesteps all the complicated floating point issues, but per MDN support is still incomplete - Safari doesn't support passing arguments to
`toLocaleString`

yet. - anyone - @MarkAmery For now, only Android Browser have some issues: caniuse.com/#search=toLocaleString - anyone
- It's usable now. caniuse.com/mdn-javascript_builtins_number_tolocalestring - anyone

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 2023-09-20 20:13:10

- Your solution does not cover some cases as opposed to MDN's solution. While it may be shorter, it is not accurate... - anyone
- round(-1835.665,2) => -1835.66 - anyone

Keep the type as integer for later sorting or other arithmetic operations:

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

1.78

```
// Round up!
Math.ceil(1.7777777 * 100)/100
```

1.78

```
// Round down!
Math.floor(1.7777777 * 100)/100
```

1.77

Or convert to a string:

```
(1.7777777).toFixed(2)
```

"1.77"

Answered 2023-09-20 20:13:10

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 2023-09-20 20:13:10

- Math.round(1.965 * 100) / 100 will be 1.96 . it's wrong. - anyone

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

Modern syntax alternative with fallback values

```
const roundToX = (num = 0, X = 2) => +(Math.round(num + `e${X}`) + `e-${X}`)
```

And the newest ES notation 💚 with power `**`

:

```
const roundToX = (num = 0, decimals = 2) => Math.round(num * 10 ** decimals) / 10 ** decimals;
```

Answered 2023-09-20 20:13:10

- That's a nice way to rewrite the accepted answer to accept an argument using
`E`

notation. - anyone - This doesn't work in some edge cases: try (jsfiddle)
`roundToX(362.42499999999995, 2)`

. Expected result (as in PHP`echo round(362.42499999999995, 2)`

):`362.43`

. Actual result:`362.42`

- anyone - IMHO, your PHP result is wrong. No matter what comes after the third decimal, if the third decimal is lower than 5, then the second decimal should remain the same. That's the mathematical definition. - anyone
- To be even more concise "e+" can just be "e" instead. - anyone

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

`toFixed(2)`

: Here *2* is the number of digits up to which we want to round this number.

Answered 2023-09-20 20:13:10

- this .toFixed() is more simple to implement. just go through it once. - anyone
- An explanation would be in order. E.g., what does this "Number" function do? Why is it required? What is the idea/gist? Some more input and output values would also be good, e.g. the previously mentioned
`1.005`

. From the Help Center:*"...always explain why the solution you're presenting is appropriate and how it works"*. Please respond by editing (changing) your answer, not here in comments ("Edit:", "Update:", or similar - the answer should appear as if it was written today). - anyone*without*

See AmrAli's answer for a more thorough run through and performance breakdown of all the various adaptations of this solution.

```
var DecimalPrecision = (function(){
if (Number.EPSILON === undefined) {
Number.EPSILON = Math.pow(2, -52);
}
if(Number.isInteger === undefined){
Number.isInteger = function(value) {
return typeof value === 'number' &&
isFinite(value) &&
Math.floor(value) === value;
};
}
this.isRound = function(n,p){
let l = n.toString().split('.')[1].length;
return (p >= l);
}
this.round = function(n, p=2){
if(Number.isInteger(n) || this.isRound(n,p))
return n;
let r = 0.5 * Number.EPSILON * n;
let o = 1; while(p-- > 0) o *= 10;
if(n<0)
o *= -1;
return Math.round((n + r) * o) / o;
}
this.ceil = function(n, p=2){
if(Number.isInteger(n) || this.isRound(n,p))
return n;
let r = 0.5 * Number.EPSILON * n;
let o = 1; while(p-- > 0) o *= 10;
return Math.ceil((n + r) * o) / o;
}
this.floor = function(n, p=2){
if(Number.isInteger(n) || this.isRound(n,p))
return n;
let r = 0.5 * Number.EPSILON * n;
let o = 1; while(p-- > 0) o *= 10;
return Math.floor((n + r) * o) / o;
}
return this;
})();
console.log(DecimalPrecision.round(1.005));
console.log(DecimalPrecision.ceil(1.005));
console.log(DecimalPrecision.floor(1.005));
console.log(DecimalPrecision.round(1.0049999));
console.log(DecimalPrecision.ceil(1.0049999));
console.log(DecimalPrecision.floor(1.0049999));
console.log(DecimalPrecision.round(2.175495134384,7));
console.log(DecimalPrecision.round(2.1753543549,8));
console.log(DecimalPrecision.round(2.1755465135353,4));
console.log(DecimalPrecision.ceil(17,4));
console.log(DecimalPrecision.ceil(17.1,4));
console.log(DecimalPrecision.ceil(17.1,15));
```

Answered 2023-09-20 20:13:10

- (DecimalPrecision.round(0.014999999999999999, 2)) // returns 0.02 - anyone
- @KFish
`DecimalPrecision.ceil(17,0); // 18`

and`DecimalPrecision.ceil(17,1); // 17.1`

- anyone - @KFish
`DecimalPrecision.ceil(-5.12, 1); // -5.2`

and`DecimalPrecision.floor(-5.12, 1); // -5.1`

- anyone - Regardless of any approach, it's important that people understand that there are always going to be some edge cases that don't evaluate correctly. For example in either your version or mine, this DecimalPrecision.ceil(10000000000000000.00111, 4) produces this result 10000000000000000, when it should technically be 10000000000000000.0012. Due to the handling of exponential notation, I would recommend your version over mine, but people need to realize that at best are only ever reducing the probability of error. - anyone
- "Edit", "Update", etc. do not belong in this post. It ought to be changed to be as if it was written right now. The
retains the previous versions for ever. See e.g.*revision history**Is it recommended to notify the answer "Edits" with an heading followed by the edit content?*,*When is "EDIT"/"UPDATE" appropriate in a post?*, and*Why are new editors discouraged & not given an opportunity to explain/defend?*- anyone