JavaScript: Round to a number of decimal places, but strip extra zeros

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, t开发者_JAVA百科here would be exactly as many decimal places as necessary (up to 15).

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

most efficient and bets method I found is below

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

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.

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