JavaScript: 四舍五入到小数位数，但是去掉额外的零

>>> parseFloat(0.9999999.toFixed(4));
1
>>> parseFloat(0.0009999999.toFixed(4));
0.001
>>> parseFloat(0.0000009999999.toFixed(4));
0

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/

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

Number(n.toFixed(15)) or +(n.toFixed(15)) will convert the 15 place decimal string to a number, removing trailing zeroes.

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.

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

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

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.

most efficient and bets method I found is below

function round(value, decimals) {
return Number(Math.round(value+'e'+decimals)+'e-'+decimals);
}

You can use The toFixed() method to format a number using fixed-point notation. Keep in mind that the parameter may be a value between 0 and 20. This returns your rounded number as a string, but it will still contain the trailing zeros. You can then use parseFloat to get your rounded number without the trailing zeros. Examples:

function prettyRound(num, decimals) {
return parseFloat(num.toFixed(decimals));
}


const numberToRound = 1.12006
console.log(prettyRound(numberToRound, 3))


const anotherToRound = 1.10006
console.log(prettyRound(anotherToRound, 4))