JavaScript display only X decimal places, no rounding

Question

I know this question has been asked before but there are a few issues with the answers that have been given that I am trying to fix.

Here is one I found with the following answer:

function calc(number) {
    var num = number;
    var with2Decimals = num.toString().match(/^-?\d+(?:\.\d{0,2})?/)[0];
    return with2Decimals
}

Here is another one I found that works in the same way that I like a little better:

function decimalFix(numToBeTruncated, numOfDecimals) { 
    var theNumber = numToBeTruncated.toString(); 
    var pointIndex = theNumber.indexOf('.');
    return +(theNumber.slice(0, pointIndex > -1 ? ++numOfDecimals + pointIndex : undefined)); 
}

The issue:

For the most part they work nicely except for extremely large decimal numbers. For example, the number 0.00000001990202020291 reads as 1.99020202029e-8 in javascript so instead of giving me 0.000000019 if I wanted 9 decimal places in it would give me 1.99020202 which is extremely off base.

Why??????

A lot of people have been really upset that I / other people would even want to tackle this issue because it seems unorthodox to them. It mostly has to do with currency and not loosing fractions of the value if I'm only allowed to be so exact in my calculations. For example there are times where I need to calculate micro transactions up to 6-8 decimal places but I'm loosing or gaining money in the process if I choose to round.

I appreciate any help or guidance someone can bring to this issue.

Expected results:

decimalFix(0.0000000199020202029,9) // 0.000000019

How large can the values get (significant digits to the *left* of the decimal)? — T.J. Crowder, Jan 06 '18 at 18:33
@T.J.Crowder I doubt it would be more then 6-8 digits to the left. Mostly I'm dealing with 1-3 — bryan, Jan 06 '18 at 18:35
If you're concerned about losing accuracy store all of your values as integers then just place the decimal point in the right place when outputting. This is even more important as you're dealing with money — Nick is tired, Jan 06 '18 at 18:39
https://stackoverflow.com/questions/1685680/how-to-avoid-scientific-notation-for-large-numbers-in-javascript — Slai, Jan 06 '18 at 18:44
What about numbers such as `100000000000000050` which are valid 64bit floating point numbers but when truncated to e.g. `10000000000000005` can no longer be represented as a 64bit floating point value? In this case, it would automatically be rounded to the next best valid 64bit floating point value `10000000000000004`. Are you aware of that? — le_m, Jan 06 '18 at 18:46
just a small side note .. don't rely on calculations and validations done on the client side, as those can probably be easily manipulated — Slai, Jan 06 '18 at 19:03

T.J. Crowder · Answer 1 · 2018-01-06T19:04:01.547

You've said you need 6-8 digits to the right of the decimal, and 6-8 to the left of it (but typically more like 1-3).

That's riding the edge (if really 8.8, going over the edge) of what JavaScript's number type (IEEE-754 double-precision binary floating point) can do. Regardless of where the decimal is, JavaScript's floating point has roughly 15 decimal digits of precision before you lose information. (That's not the full story by any means.)

Good news: JavaScript is getting a BigInt type you could use for this (by multiplying your values by 100,000,000 so they're whole numbers), details here. Until then, you might consider using one of the existing "big number" libraries.

If you need to use JavaScript's numbers, I would do it with whole numbers. With whole numbers, your perfectly-accurate range is -Number.MAX_SAFE_INTEGER - 1 through Number.MAX_SAFE_INTEGER + 1. That's -9,007,199,254,740,992 through 9,007,199,254,740,992. With that, you can get seven digits left of the decimal and eight right of it (or of course, eight left and seven right). So if we're using eight digits of precision right of the decimal and seven to the left (well within limits), that's -9,999,999.99999999 through 9,999,999.99999999.

Calculations would use Math.trunc to remove the fractional portion (assuming you want to truncate toward zero). Output without scientific notation is trivial:

str = String(number);
str = str.substring(0, str.length - 8) + "." + str.substr(-8);

Examples:

function toString(number) {
  var str = String(number);
  str = str.substring(0, str.length - 8) + "." + str.substr(-8);
  return str;
}
console.log(toString(999999999999999));
console.log(toString(123456712345678));
console.log(toString(765432187654321));

Thomas · Answer 2 · 2018-01-06T19:50:47.060

It mostly has to do with currency and not loosing fractions of the value if I'm only allowed to be so exact in my calculations. For example there are times where I need to calculate micro transactions up to 6-8 decimal places but I'm loosing or gaining money in the process if I choose to round.

//rounding to an arbitrary precision
function round(value, precision = 1) {
  return Math.round(value / precision) * precision
}

console.log("round");
console.log(round(1.23456789, 0.001));
console.log(round(1.23456789, 1 / 4));
console.log(round(Date.now(), 1000*60*60)); //the current timestamp rounded to the hour

//rounding to a certain amount of decimal places
function roundToDecimalPlaces(value, decimalPlaces = 0) {
  return round(value, "1e" + (-decimalPlaces));
}

console.log("roundToDecimalPlaces");
console.log(roundToDecimalPlaces(1.23456789, 4));
console.log(roundToDecimalPlaces(0.0000000199020202029, 9));

//and truncating everything after a certain amount of decimal places
function decimalFix(value, decimalPlaces = 0) {
  let precision = "1e" + (-decimalPlaces);
  return Math[value < 0 ? "ceil" : "floor"](value / precision) * precision;
}

console.log("decimalFix");
console.log(decimalFix(0.0000000199020202029, 9));

.as-console-wrapper {
  top: 0;
  max-height: 100%!important
}

But why do you want to limit the precision in the first place? If it's abount the view, and how the values are displayed, then this is the wrong approach.

Then you should check out Number#toFixed, Number#toPrecision and Number#toLocaleString

JavaScript display only X decimal places, no rounding

The issue:

Why??????

Expected results:

2 Answers2