在JavaScript中使用正好两个小数格式化数字

我有一行代码，它把我的数字四舍五入到小数点后两位。但是我得到的数字是这样的：10.8，2.4，等等。这些不是我的想法，小数点后两位，那么我如何改进下面的内容呢

Math.round(price*Math.pow(10,2))/Math.pow(10,2);

---

我想要10.80、2.40等数字。我可以使用jQuery。

要使用定点表示法格式化数字，只需使用以下方法：

注意，toFixed返回一个字符串

重要提示：注意toFixed不会在90%的时间内取整，它将返回取整后的值，但在许多情况下，它不起作用

例如：

2.005.toFixed2===2.00

更新： 现在，您可以使用构造函数。这是ECMA402的一部分。它有，甚至包括IE11，它是

const formatter=new Intl.NumberFormat'en-US'{ 最小分数位数：2， 最大分数位数：2， }; console.logformatter.format2.005；//2.01 console.logformatter.format1.345；//1.35 toFixedn在小数点后提供n个长度；toPrecisionx 提供x总长度

使用下面的方法

// Example: toPrecision(4) when the number has 7 digits (3 before, 4 after)
    // It will round to the tenths place
    num = 500.2349;
    result = num.toPrecision(4); // result will equal 500.2

如果你想固定电话号码，请使用

result = num.toFixed(2);

---

@heridev和我在jQuery中创建了一个小函数

您可以尝试下一步：

HTML

​ 在线演示：

---

我通常会将其添加到我的个人库中，在提出一些建议并使用@TimiNeuton解决方案后，使其适合十进制长度，然后，此解决方案最适合：

function precise_round(num, decimals) {
   var t = Math.pow(10, decimals);   
   return (Math.round((num * t) + (decimals>0?1:0)*(Math.sign(num) * (10 / Math.pow(100, decimals)))) / t).toFixed(decimals);
}

---

将适用于报告的异常。

我没有找到此问题的准确解决方案，因此我创建了自己的：

function inprecise_round(value, decPlaces) {
  return Math.round(value*Math.pow(10,decPlaces))/Math.pow(10,decPlaces);
}

function precise_round(value, decPlaces){
    var val = value * Math.pow(10, decPlaces);
    var fraction = (Math.round((val-parseInt(val))*10)/10);

    //this line is for consistency with .NET Decimal.Round behavior
    // -342.055 => -342.06
    if(fraction == -0.5) fraction = -0.6;

    val = Math.round(parseInt(val) + fraction) / Math.pow(10, decPlaces);
    return val;
}

示例：

函数inprecise_roundvalue，deplaces{ 返回Math.roundvalue*Math.pow10，deplaces/Math.pow10，deplaces； } 函数精确舍入值，deplaces{ var val=值*Math.pow10，小数位数； var分数=Math.roundval-parseIntval*10/10； //此行用于与.NET Decimal.Round行为保持一致 // -342.055 => -342.06 如果分数==-0.5，分数=-0.6； val=Math.roundparseIntval+分数/Math.pow10，小数位数； 返回val； } //这可能会根据浏览器环境产生不同的结果 console.log342.055.toFixed2:，342.055.toFixed2；//铬合金和IE10上的342.06 console.login精确循环342.055,2:，精确循环342.055,2；//342.05 console.logprecision_round342.055,2:，precision_round342.055,2；//342.06 console.logprecise_round-342.055，2:，precise_round-342.055，2；//-342.06 console.login精确循环0.565,2:，精确循环0.565,2；//0.56

---

console.logprecision_round0.565,2:，precision_round0.565,2；//0.57我不知道为什么我不能在之前的回答中添加一条评论也许我完全失明了，我不知道，但我用@Miguel的回答想出了一个解决方案：

function precise_round(num,decimals) {
   return Math.round(num*Math.pow(10, decimals)) / Math.pow(10, decimals);
}

以及@bighostkim和@Imre的两条评论：

精确_round1.275,2不返回1.28的问题 精确循环6,2出现问题，无法按他所希望的返回6.00。 我的最终解决办法如下：

function precise_round(num,decimals) {
    var sign = num >= 0 ? 1 : -1;
    return (Math.round((num*Math.pow(10,decimals)) + (sign*0.001)) / Math.pow(10,decimals)).toFixed(decimals);
}

正如你所看到的，我不得不添加一点修正，但事实并非如此，但由于Math.round是有损的-你可以在jsfiddle.net上检查它-这是我知道如何修复它的唯一方法。它在已经填充的数字上加0.001，因此在十进制值的右边加一个1到3 0。所以使用起来应该是安全的

之后，我添加了.toFixeddecimal，以便始终以正确的格式输出数字，并使用正确的小数量

差不多就是这样。善用它

---

编辑：为负数的校正添加了功能。

浮点值的问题在于，它们试图用固定的位表示无限量的连续值。所以很自然，游戏中肯定会有一些损失，你会被一些价值观所侵蚀

当计算机将1.275存储为浮点值时，它实际上不会记住它是1.275还是1.27499999999993，甚至是1.27500000000000002。在四舍五入到两位小数后，这些值应该给出不同的结果，但它们不会，因为对于计算机来说，它们在存储为浮点值后看起来完全相同，并且无法恢复丢失的数据。任何进一步的计算只会累积这种不精确性

因此，如果精度很重要，您必须从一开始就避免使用浮点值。最简单的选择是

使用 使用字符串存储和传递伴随字符串操作的值 使用整数，例如，您可以传递实际值的百分之一百，例如，以美分表示的金额，而不是以美元表示的金额 例如，当使用整数存储百分位数时，查找实际值的函数非常简单：

function descale(num, decimals) {
    var hasMinus = num < 0;
    var numString = Math.abs(num).toString();
    var precedingZeroes = '';
    for (var i = numString.length; i <= decimals; i++) {
        precedingZeroes += '0';
    }
    numString = precedingZeroes + numString;
    return (hasMinus ? '-' : '') 
        + numString.substr(0, numString.length-decimals) 
        + '.' 
        + numString.substr(numString.length-decimals);
}

alert(descale(127, 2));

对于字符串，您需要舍入，但仍然可以管理：

function precise_round(num, decimals) {
    var parts = num.split('.');
    var hasMinus = parts.length > 0 && parts[0].length > 0 && parts[0].charAt(0) == '-';
    var integralPart = parts.length == 0 ? '0' : (hasMinus ? parts[0].substr(1) : parts[0]);
    var decimalPart = parts.length > 1 ? parts[1] : '';
    if (decimalPart.length > decimals) {
        var roundOffNumber = decimalPart.charAt(decimals);
        decimalPart = decimalPart.substr(0, decimals);
        if ('56789'.indexOf(roundOffNumber) > -1) {
            var numbers = integralPart + decimalPart;
            var i = numbers.length;
            var trailingZeroes = '';
            var justOneAndTrailingZeroes = true;
            do {
                i--;
                var roundedNumber = '1234567890'.charAt(parseInt(numbers.charAt(i)));
                if (roundedNumber === '0') {
                    trailingZeroes += '0';
                } else {
                    numbers = numbers.substr(0, i) + roundedNumber + trailingZeroes;
                    justOneAndTrailingZeroes = false;
                    break;
                }
            } while (i > 0);
            if (justOneAndTrailingZeroes) {
                numbers = '1' + trailingZeroes;
            }
            integralPart = numbers.substr(0, numbers.length - decimals);
            decimalPart = numbers.substr(numbers.length - decimals);
        }
    } else {
        for (var i = decimalPart.length; i < decimals; i++) {
            decimalPart += '0';
        }
    }
    return (hasMinus ? '-' : '') + integralPart + (decimals > 0 ? '.' + decimalPart : '');
}

alert(precise_round('1.275', 2));
alert(precise_round('1.27499999999999993', 2));

请注意，此函数将舍入到离零最近的ties，而建议舍入到最近的ties，甚至作为浮点运算的默认行为 是的。这些修改留给读者作为练习：

这里有一个简单的修改

function roundFloat(num,dec){
    var d = 1;
    for (var i=0; i<dec; i++){
        d += "0";
    }
    return Math.round(num * d) / d;
}

使用类似alertroundFloat1.79209243929,4

---

有一种方法可以100%确保您得到一个2位小数的数字：

(Math.round(num*100)/100).toFixed(2)

如果这导致舍入错误，您可以使用以下内容，正如James在其评论中所解释的：

(Math.round((num * 1000)/10)/100).toFixed(2)

---

这是一个古老的话题，但仍然是排名第一的谷歌结果和提供的解决方案共享相同的浮点小数问题。下面是我使用的非常通用的函数：

正如我们所见，我们不了解这些问题：

round(1.275, 2);   // Returns 1.28
round(1.27499, 2); // Returns 1.27

这种通用性还提供了一些很酷的东西：

round(1234.5678, -2);   // Returns 1200
round(1.2345678e+2, 2); // Returns 123.46
round("123.45");        // Returns 123

现在，要回答OP的问题，必须键入：

round(10.8034, 2).toFixed(2); // Returns "10.80"
round(10.8, 2).toFixed(2);    // Returns "10.80"

或者，对于更简洁、不太通用的函数：

function round2Fixed(value) {
  value = +value;

  if (isNaN(value))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + 2) : 2)));

  // Shift back
  value = value.toString().split('e');
  return (+(value[0] + 'e' + (value[1] ? (+value[1] - 2) : -2))).toFixed(2);
}

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

您可以通过以下方式调用它：

round2Fixed(10.8034); // Returns "10.80"
round2Fixed(10.8);    // Returns "10.80"

各种示例和测试感谢！：

函数roundvalue，exp{ 如果typeof exp==“未定义”| |+exp===0 返回Math.roundvalue； 值=+值； exp=+exp； 如果isNaNvalue | |！typeof exp=='number'&exp%1==0 返回NaN； //移位 value=value.toString.split'e'； value=Math.round+value[0]+'e'+value[1]？+value[1]+exp:exp； //向后移动 value=value.toString.split'e'； 返回+值[0]+'e'+值[1]？+值[1]-exp:-exp； } 函数值，exp{ 如果！exp{ 返回Math.roundvalue； } var pow=Math.pow10，exp； 返回Math.roundvalue*pow/pow； } 函数testval，位置{ 次测验，地点； val=typeof val==字符串？-+val:-val； 次测验，地点； } 函数子测试，位置{ var placesOrZero=位置| | 0； var naiveResult=naiveval，位置； var roundResult=roundval，位置； 如果placesOrZero>=0{ naiveResult=naiveResult.toFixedplacesOrZero； roundResult=roundResult.toFixedplacesOrZero； }否则{ naiveResult=naiveResult.toString； roundResult=roundResult.toString； } $ .append$.textJSON.stringifyval .append$.textplacesOrZero .append$.textnaiveResult .append$.textroundResult .附录结果； } 试验0.565,2； test0.575,2； 试验0.585,2； 测试1.275,2； test1.27499,2； test1234.5678，-2； 测试1.2345678e+2,2； test123.45； test10.8034，2； 测试10.8,2； test1.005，2； 测试1.0005，2； 桌子{ 边界塌陷：塌陷； } 表，td，th{ 边框：1px实心ddd； } td，th{ 填充：4px； } th{ 字体大小：正常； 字体系列：无衬线； } 运输署{ 字体系列：monospace； } 输入 地点 缺乏经验的 彻底的 将以下内容放在一些全局范围内：

Number.prototype.getDecimals = function ( decDigCount ) {
   return this.toFixed(decDigCount);
}

然后尝试：

使现代化 请注意，toFixed只能用于0-20之间的小数数，即a.getDecimals25可能会生成javascript错误，因此您可以添加一些额外的检查，即

Number.prototype.getDecimals = function ( decDigCount ) {
   return ( decDigCount > 20 ) ? this : this.toFixed(decDigCount);
}

---

将十进制值四舍五入，然后使用toFixedx表示期望的数字

function parseDecimalRoundAndFixed(num,dec){
  var d =  Math.pow(10,dec);
  return (Math.round(num * d) / d).toFixed(dec);
}

召唤

ParseDecimalRoundFixed10.800243929,4=>10.80 ParseDecimalRoundFixed10.807243929,2=>10.81

Number(Math.round(1.005+'e2')+'e-2'); // 1.01

这对我很有用：

该收益率应为：10.20

这将产生：0.05

该收益率应为：4.04

---

等等。

我正在用修饰符修复问题。 仅支持2位小数

$function{ //只输入数字。 convertNumberFloatZero22；//输出：22.00 convertNumberFloatZero22.5；//输出：22.50 convertNumberFloatZero22.55；//输出：22.55 convertNumberFloatZero22.556；//输出：22.56 convertNumberFloatZero22.555；//输出：22.55 convertNumberFloatZero22.5541；//输出：22.54 ConvertNumberFloatzero2222.5541；//输出：2222.54 函数转换器NumberFloatzerNumber{ 如果！$.isNumericnumber{ 返回'NaN'； } var numberFloat=number.toFixed3； var splitNumber=numberFloat.split。； var cNumberFloat=number.toFixed2； var cNsplitNumber=cNumberFloat.split。； var lastChar=splitNumber[1]。substrsplitNumber[1]。长度-1； iflastChar>0&&lastChar<5{ cNsplitNumber[1]； } 返回NumbersplitNumber[0]。toLocalString'en'。concat'。concatcNsplitNumber[1]； }; }; 这将返回一个从1到100的随机数，四舍五入到小数点后2位。

/*因为所有的事情。你可以为不同的目的做两件事： 显示/打印内容时，请在警报/innerHtml=内容中使用此选项： 你的RebelNumber.ToFixed 2*/ var aNumber=9242.16； 变量YourRebelNumber=aNumber-9000； 警报号码； 提醒您的RebelNumber.toFixed2； /*在比较使用时： number您的RebelNumber.ToFixed 2*/ 如果您的RebelNumber==242.16L未四舍五入； ifNumberYourRebelNumber.toFixed2==242.16alertRounded； /*在那个时刻，数字将按您的意愿运行。在那之后，它将回到它的反抗。

---

*/ 这非常简单，与其他任何方法一样有效：

function parseNumber(val, decimalPlaces) {
    if (decimalPlaces == null) decimalPlaces = 0
    var ret = Number(val).toFixed(decimalPlaces)
    return Number(ret)
}

由于toFixed只能在数字上调用，并且不幸地返回一个字符串，因此这将在两个方向上为您完成所有解析。你可以传递一个字符串或一个数字，每次你都会得到一个数字！调用parseNumber1.49将得到1，而parseNumber1.49,2将得到1.50。就像他们中最好的

您也可以为我们服务 e.toPrecision方法和一些自定义代码，并始终四舍五入到第n个十进制数字，而不考虑int部分的长度

function glbfrmt (number, decimals, seperator) {
    return typeof number !== 'number' ? number : number.toPrecision( number.toString().split(seperator)[0].length + decimals);
}

---

您还可以将其作为一个插件，以便更好地使用。

通过引用使用此响应：

我构建了一个函数来获取动态小数位数：

function toDec(num, dec)
{
        if(typeof dec=='undefined' || dec<0)
                dec = 2;

        var tmp = dec + 1;
        for(var i=1; i<=tmp; i++)
                num = num * 10;

        num = num / 10;
        num = Math.round(num);
        for(var i=1; i<=dec; i++)
                num = num / 10;

        num = num.toFixed(dec);

        return num;
}

下面是工作示例：

parse=函数数据{ data=Math.rounddata*Math.pow10,2/Math.pow10,2； 如果数据！=null{ var lastone=data.toString.split.pop； 如果最后一个{ 数据=解析数据； } } 返回数据； }; $'result'.htmlparse200；//输出200 $'result1'.htmlparse200.1；//产出200.1 $'result2'.htmlparse200.10；//产出200.1 $'result3'.htmlparse200.109；//产出200.11 四舍五入

围捕

四舍五入

合并和 谢谢 他们

---

在这些示例中，尝试将数字1.005四舍五入时仍然会出现错误。解决方案是使用Math.js之类的库或以下函数：

function round2Fixed(value) {
  value = +value;

  if (isNaN(value))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + 2) : 2)));

  // Shift back
  value = value.toString().split('e');
  return (+(value[0] + 'e' + (value[1] ? (+value[1] - 2) : -2))).toFixed(2);
}

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

---

通常，小数舍入是通过缩放：roundnum*p/p来完成的

天真的实现

使用以下带有中间数字的函数，您将获得预期的上舍入值，或者有时根据输入获得下舍入值

舍入中的这种不一致可能会在客户端代码中引入难以检测的错误

函数名，小数位数{ var p=数学功率10，小数位数； 返回Math.roundnum*p/p； } console.log.1.245，2；//1.25按预期四舍五入

---

console.log.1.255，2；//1.25不正确应为1.26这是我的单线解决方案：NumberyourNumericValueHere.toFixed2

下面是发生的情况：

1首先，将.toFixed2应用到要舍入小数位数的数字上。请注意，这将把值从数字转换为字符串。因此，如果您使用的是Typescript，它将抛出如下错误：

类型“string”不可分配给类型“number”

2要返回数值或将字符串转换为数值，只需对所谓的“字符串”值应用Number函数

有关说明，请参见以下示例：

例如： 我有一个金额，有多达5位小数点位，我想缩短到多达2位小数点位。我是这样做的：

var价格=0.26453； var价格四舍五入=Numberprice.toFixed2； 控制台。日志“原价：”+价格；

---

console.log“价格四舍五入：”+价格四舍五入 几个月前，我从这篇文章中得到了一些想法，但这里的答案和其他文章/博客的答案都不能处理所有情况，例如测试人员发现的负数和一些幸运数。最后，我们的测试人员没有发现下面这种方法有任何问题。粘贴我的代码片段：

fixPrecision: function (value) {
    var me = this,
        nan = isNaN(value),
        precision = me.decimalPrecision;

    if (nan || !value) {
        return nan ? '' : value;
    } else if (!me.allowDecimals || precision <= 0) {
        precision = 0;
    }

    //[1]
    //return parseFloat(Ext.Number.toFixed(parseFloat(value), precision));
    precision = precision || 0;
    var negMultiplier = value < 0 ? -1 : 1;

    //[2]
    var numWithExp = parseFloat(value + "e" + precision);
    var roundedNum = parseFloat(Math.round(Math.abs(numWithExp)) + 'e-' + precision) * negMultiplier;
    return parseFloat(roundedNum.toFixed(precision));
},

---

我找到了一个非常简单的方法来解决这个问题，并且可以使用或调整：

td[row].innerHTML = price.toPrecision(price.toFixed(decimals).length

---

下面是的TypeScript实现。它还可以通过函数使事情干涸，并允许可选的数字偏移量

导出函数roundrawValue:number |字符串，精度=0，fractionDigitoOffset=0:number |字符串{ 常量值=NumberrawValue； 如果为NanValue，则返回原始值； 精度=数字精度； 如果精度为%1！==0，则返回NaN； 设[stringValue，exponent]=科学符号到零件值； 设shiftextponent=精度指数，精度，Shift.Right； 常量放大值=toScientificNotationstringValue，移位分量； const roundedValue=Math.roundenlargedValue； [stringValue，exponent]=科学符号到PartsRoundedValue； const precisionWithOffset=精度+分数位数偏移； shiftExponent=精度指数的指数，带偏移的精度，Shift.Left； 返回到ScientificNotationStringValue，shifteComponent； } 枚举移位{ 左=-1， 右=1， } 函数scientificNotationToPartsvalue:编号：数组{ 常量[stringValue，exponent]=value.toString.split'e'； 返回[字符串值，指数]； } 函数指数精度指数：字符串，精度：数字，移位：移位：数字{ 精度=移位*精度； 返回指数？NumberComponent+精度：精度； } 函数toScientificNotationvalue:字符串，指数：数字：数字{ 返回数`${value}e${exponent}`； } 快捷 parseFloatnumber.toFixed2 实例 let number=2.55435930 设roundedString=number.toFixed2//2.55 设twoDecimalsNumber=parseFloatroundedString//2.55 let directly=parseFloatnumber.toFixed2//2.55 在此基础上，执行以下操作将输出一个数字类型，并且似乎能够很好地处理舍入问题：

const roundNumberToTwoDecimalPlaces = (num) => Number(new Intl.NumberFormat('en-US', {
  minimumFractionDigits: 2,
  maximumFractionDigits: 2,
}).format(num));

roundNumberToTwoDecimalPlaces(1.344); // => 1.34
roundNumberToTwoDecimalPlaces(1.345); // => 1.35

---

上述内容与前面提到的内容之间的区别在于，在使用时不需要.format链接[，并且它输出一个数字类型]。

不能在所有浏览器上一致工作，即0.09.toFixed1；在IE8fixed中给出0.0。如果不舍入，则可以使用f

---

---

第一名：Math.round0.09.toFixed1@雷肯：这是错误的。Math.Round0.09将返回0，因此这将始终为0.0…在大多数情况下，这是一个坏主意，在某些情况下，它会将数字转换为字符串或浮点数。在这里必须同意@AshBlue。。。这仅适用于格式化值的表示形式。进一步计算可能会破坏代码。否则，Math.roundvalue*100/100对于2DP效果更好。precision_round1.275,2是1.27？@Imre将返回值更改为Math.roundnum*Math.pow10，decimals/Math.pow10，decimals.toFixed2；你将不再有这个问题。如果你的第二个函数按原样提取，你在哪里声明sign和dec？不应该将它们定义为未定义吗？我在IE中为missign sign方法添加了一个WorkAround:@Armin你的修复程序也使它在Safari中工作。原始功能在Safari中不起作用。谢谢。这里有一首小曲来测试这一点：。在返回值之前，我将对该值应用toFixed，它会在返回值的末尾添加正确数量的零。不使用value=0004990845956707237和inprecise_roundvalue，8返回000499085，但它必须返回000499084。更正基本上是安全的，但例如，precise_round1.27499,2现在也返回1.28。。。这不是数学，这是有损的；计算机内部存储浮点值的方式是。基本上，在数据到达您的函数之前，您注定会失败，因为某些值：@Imre，您完全正确。这就是为什么我解释这个0.001在那里做什么，以防有人想让它更精确，或者如果你碰巧有一台超级计算机，每个浮点2兆字节，甚至删除它，我想这里没有人这样做；事实上，使用64位表示数值是非常具体的，因此拥有/使用超级计算机不会改变任何事情：对于0.001，可以根据小数的长度添加许多零来替换。所以..我很欣赏这一贡献，尽管我认为将DOM元素和jQuery添加到混合中似乎超出了问题的范围。您不应该听keyup事件，因为它看起来非常糟糕，并且在添加脚本时不会激活。我宁愿听输入事件。这不会产生闪烁效果，当您使用JSit访问字段时也会激发，但效果不好。。。对于number num=50.2349，您应该编写toPrecision3以获得50.2。这只是一个示例，您可以根据需要进行更改@PiotrCzyż这是最好、最简单的方法。但是，由于浮点运算，1.275*100=127.499999999，这可能会导致舍入中的微小错误。为了解决这个问题，我们可以乘以1000除以10，即1.275*1000/10=127.5。如下所示：var answer=Math.roundnum*1000/10/100.toFixed2；Math.round1.015*1000/10/100.toFixed2仍然是1.01，不是应该是1.02吗？您的代码正是我想要的，可以将较小的JSON文件的浮点精度降低到小数点后7位，跳过Math.pow以获得speed val=Math.roundval*10000000/10000000；由于数字0.565、0.575、1.005中固有的不精确性加剧，因此对于大范围的值，可以说给出了一个错误的结果，我建议您再看一看，哪一个是正确的？也许您希望在使用小数点移位和舍入方法正确舍入后，包含一个sprintf JavaScript库，您可以使用该方法将其转换为具有所需数量的零的字符串。例如，使用跨浏览器方法将1.34取整为1.3，然后添加1 0，并使用1.3.toFixed2转换为字符串，得到1.30。现在是2020年，JavaScript中没有简单的本机方法简单地将数字取整。哇，怎么没有一个简单的方法可以做到这一点呢？ES6救援？感谢您发布MDN polyfill。在链接的MDN页面上，polyfill不再存在。我想知道为什么它被删除了……我如何使用它来获取小数点后第一位的值，比如3.0421 shuld return 3.0？@RIni，你应该能够使用round3.0421，1来获取3作为数字，或者round3.0421，1.toFixed1来获取“3.0”作为字符串。在搜索了一段时间后，这终于对我起作用了，简单易行

function parseNumber(val, decimalPlaces) {
    if (decimalPlaces == null) decimalPlaces = 0
    var ret = Number(val).toFixed(decimalPlaces)
    return Number(ret)
}

function glbfrmt (number, decimals, seperator) {
    return typeof number !== 'number' ? number : number.toPrecision( number.toString().split(seperator)[0].length + decimals);
}

function toDec(num, dec)
{
        if(typeof dec=='undefined' || dec<0)
                dec = 2;

        var tmp = dec + 1;
        for(var i=1; i<=tmp; i++)
                num = num * 10;

        num = num / 10;
        num = Math.round(num);
        for(var i=1; i<=dec; i++)
                num = num / 10;

        num = num.toFixed(dec);

        return num;
}

function round_down(value, decPlaces) {
    return Math.floor(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

function round_up(value, decPlaces) {
    return Math.ceil(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

function round_nearest(value, decPlaces) {
    return Math.round(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

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

fixPrecision: function (value) {
    var me = this,
        nan = isNaN(value),
        precision = me.decimalPrecision;

    if (nan || !value) {
        return nan ? '' : value;
    } else if (!me.allowDecimals || precision <= 0) {
        precision = 0;
    }

    //[1]
    //return parseFloat(Ext.Number.toFixed(parseFloat(value), precision));
    precision = precision || 0;
    var negMultiplier = value < 0 ? -1 : 1;

    //[2]
    var numWithExp = parseFloat(value + "e" + precision);
    var roundedNum = parseFloat(Math.round(Math.abs(numWithExp)) + 'e-' + precision) * negMultiplier;
    return parseFloat(roundedNum.toFixed(precision));
},

9.995 * 100 = 999.4999999999999
Whereas 9.995e2 = 999.5
This discrepancy causes Math.round(9.995 * 100) = 999 instead of 1000.
Use e notation instead of multiplying /dividing by Math.Pow(10,precision).

td[row].innerHTML = price.toPrecision(price.toFixed(decimals).length

const roundNumberToTwoDecimalPlaces = (num) => Number(new Intl.NumberFormat('en-US', {
  minimumFractionDigits: 2,
  maximumFractionDigits: 2,
}).format(num));

roundNumberToTwoDecimalPlaces(1.344); // => 1.34
roundNumberToTwoDecimalPlaces(1.345); // => 1.35