How to parse float with two decimal places in javascript?

If you need performance (like in games):

Math.round(number * 100) / 100

It's about 100 times as fast as parseFloat(number.toFixed(2))

http://jsperf.com/parsefloat-tofixed-vs-math-round

EDIT:

https://jsperf.app/kowulu

When you use toFixed, it always returns the value as a string. This sometimes complicates the code. To avoid that, you can make an alternative method for Number.

Number.prototype.round = function(p) {
  p = p || 10;
  return parseFloat( this.toFixed(p) );
};

and use:

var n = 22 / 7; // 3.142857142857143
n.round(3); // 3.143

or simply:

(22/7).round(3); // 3.143

To return a number, add another layer of parentheses. Keeps it clean.

var twoPlacedFloat = parseFloat((10.02745).toFixed(2));

If your objective is to parse, and your input might be a literal, then you'd expect a float and toFixed won't provide that, so here are two simple functions to provide this:

function parseFloat2Decimals(value) {
    return parseFloat(parseFloat(value).toFixed(2));
}

function parseFloat2Decimals(value,decimalPlaces) {
    return parseFloat(parseFloat(value).toFixed(decimalPlaces));
}

ceil from lodash is probably the best

_.ceil("315.9250488",2) 
_.ceil(315.9250488,2) 
_.ceil(undefined,2)
_.ceil(null,2)
_.ceil("",2)

will work also with a number and it's safe

parseFloat(parseFloat(amount).toFixed(2))

You have to parse it twice. The first time is to convert the string to a float, then fix it to two decimals (but the toFixed returns a string), and finally parse it again.

You can use .toFixed() to for float value 2 digits

Exampale

let newValue = parseFloat(9.990000).toFixed(2)

//output
9.99

I have tried this for my case and it'll work fine.

var multiplied_value = parseFloat(given_quantity*given_price).toFixed(3);

Sample output:

9.007

Please use below function if you don't want to round off.

function ConvertToDecimal(num) {
    num = num.toString(); //If it's not already a String
    num = num.slice(0, (num.indexOf(".")) + 3); //With 3 exposing the hundredths place
   alert('M : ' +  Number(num)); //If you need it back as a Number    
}

For what its worth: A decimal number, is a decimal number, you either round it to some other value or not. Internally, it will approximate a decimal fraction according to the rule of floating point arthmetic and handling. It stays a decimal number (floating point, in JS a double) internally, no matter how you many digits you want to display it with.

To present it for display, you can choose the precision of the display to whatever you want by string conversion. Presentation is a display issue, not a storage thing.

@sd Short Answer: There is no way in JS to have Number datatype value with trailing zeros after a decimal.

Long Answer: Its the property of toFixed or toPrecision function of JavaScript, to return the String. The reason for this is that the Number datatype cannot have value like a = 2.00, it will always remove the trailing zeros after the decimal, This is the inbuilt property of Number Datatype. So to achieve the above in JS we have 2 options

1. Either use data as a string or
2. Agree to have truncated value with case '0' at the end ex 2.50 -> 2.5.

You can store your price as a string

You can use Number(string)

for your calculations.

example

Number("34.50") == 34.5

also

Number("35.65") == 35.65

If you're comfortable with the Number function , you can go with it.

TypeScript

/**
 * Convert a number or string to a float.
 * @param value Number or string.
 * @param precision Float precision.
 * @returns Float.
 */
function toFloat(value: number | string, precision: number = 2) {
  if (!value) return 0.0;
  if (typeof value === 'string') value = parseFloat(value);
  const p = Math.pow(10, precision);
  return Math.round(value * p) / p;
}

JavaScript

/**
 * Convert a number or string to a float.
 * @param {number | string} value Number or string.
 * @param {number} precision Float precision.
 * @returns {number} Float.
 */
function toFloat(value, precision = 2) {
  if (!value) return 0.0;
  if (typeof value === 'string') value = parseFloat(value);
  const p = Math.pow(10, precision);
  return Math.round(value * p) / p;
}