问题
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).
回答1:
>>> parseFloat(0.9999999.toFixed(4));
1
>>> parseFloat(0.0009999999.toFixed(4));
0.001
>>> parseFloat(0.0000009999999.toFixed(4));
0
回答2:
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/
回答3:
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
回答4:
Number(n.toFixed(15)) or +(n.toFixed(15)) will convert the 15 place decimal string to a number, removing trailing zeroes.
回答5:
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.
回答6:
Mmmm, a little different answer, for cross browser too:
function round(x, n) {
return Math.round(x * Math.pow(10, n)) / Math.pow(10, n)
}
回答7:
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
回答8:
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));
回答9:
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.
来源：https://stackoverflow.com/questions/7312468/javascript-round-to-a-number-of-decimal-places-but-strip-extra-zeros