JavaScript: Round to a number of decimal places, but strip extra zeros
JavascriptMathFloating PointRoundingJavascript Problem Overview
Here's the scenario: I'm getting .9999999999999999
when I should be getting 1.0
.
I can afford to lose a decimal place of precision, so I'm using .toFixed(15)
, which kind of works.
The rounding works, but the problem is that I'm given 1.000000000000000
.
Is there a way to round to a number of decimal places, but strip extra whitespace?
Note: .toPrecision
isn't what I want; I only want to specify how many numbers after the decimal point.
Note 2: I can't just use .toPrecision(1)
because I need to keep the high precision for numbers that actually have data after the decimal point. Ideally, there would be exactly as many decimal places as necessary (up to 15).
Javascript Solutions
Solution 1 - Javascript
>>> parseFloat(0.9999999.toFixed(4));
1
>>> parseFloat(0.0009999999.toFixed(4));
0.001
>>> parseFloat(0.0000009999999.toFixed(4));
0
Solution 2 - Javascript
Yes, there is a way. Use parseFloat()
.
parseFloat((1.005).toFixed(15)) //==> 1.005
parseFloat((1.000000000).toFixed(15)) //==> 1
See a live example here: http://jsfiddle.net/nayish/7JBJw/
Solution 3 - Javascript
As I understand, you want to remove the trailing zeros in the string that you obtained via toFixed()
. This is a pure string operation:
var x = 1.1230000;
var y = x.toFixed(15).replace(/0+$/, ""); // ==> 1.123
Solution 4 - Javascript
Number(n.toFixed(15)) or +(n.toFixed(15))
will convert the 15 place decimal string to a number, removing trailing zeroes.
Solution 5 - Javascript
If you cast the return value to a number, those trailing zeroes will be dropped. This is also less verbose than parseFloat()
is.
+(4.55555).toFixed(2);
//-> 4.56
+(4).toFixed(2);
//-> 4
This uses the unary + operator, so if using this as part of a string operation you need to have an infix + before it: var n=0.9999999999999999; console.log('output ' + +n.toFixed(2));
. FYI a unary + in front of a string converts it to a Number. From MDN: Unary + can:
> convert string representations of integers and floats, as well > as the non-string values true, false, and null. Integers in both > decimal and hexadecimal ("0x"-prefixed) formats are supported. > Negative numbers are supported (though not for hex). If it cannot > parse a particular value, it will evaluate to NaN.
Solution 6 - Javascript
None of these really got me what I was looking for based on the question title, which was, for example, for 5.00 to be 5 and 5.10 to be 5.1. My solution was as follows:
num.toFixed(places).replace(/\.?0+$/, '')
'5.00'.replace(/\.?0+$/, '') // 5
'5.10'.replace(/\.?0+$/, '') // 5.1
'5.0000001'.replace(/\.?0+$/, '') // 5.0000001
'5.0001000'.replace(/\.?0+$/, '') // 5.0001
Note: The regex only works if places > 0
P.S. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed
Solution 7 - Javascript
most efficient and bets method I found is below
function round(value, decimals) {
return Number(Math.round(value+'e'+decimals)+'e-'+decimals);
}
Solution 8 - Javascript
There is a better method which keeps precision and also strips the zeros. This takes an input number and through some magic of casting will pull off any trailing zeros. I've found 16 to be the precision limit for me which is pretty good should you not be putting a satellite on pluto.
function convertToFixed(inputnum)
{
var mynum = inputnum.toPrecision(16);
//If you have a string already ignore this first line and change mynum.toString to the inputnum
var mynumstr = mynum.toString();
return parseFloat(mynumstr);
}
alert(convertToFixed(6.6/6));
Solution 9 - Javascript
The toFixed()
method formats a number
using fixed-point notation, and returns a string
.
It applies a half-up rounding strategy.
(0.124).toFixed(2); // returns 0.12
(0.125).toFixed(2); // returns 0.13
As you described, it will indeed also result in (potentially unnecessary) trailing zeroes sometimes.
(0.001).toFixed(2); // returns 0.00
You may not want to get rid of those trailing zeroes, essentially you could just convert it back to a number
. There are many ways to do this.
+(0.001).toFixed(2); // the shortest
For an overview, of the different methods to convert strings to numbers, please check this question, which has some excellent answers.