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


570

我有这行代码将我的数字四舍五入到小数点后两位。但是我得到这样的数字:10.8、2.4等。这些不是我对小数点后两位的想法,因此我如何改善以下内容?

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

我想要数字10.80、2.40等。使用jQuery对我来说很好。


1
您的代码正是我想要的(对于较小的JSON文件,将浮点精度降低到7个小数位)跳过Math.pow以获得速度val = Math.round(val * 10000000)/ 10000000);
Pawel

作为目前公认的答案可以说是给了一个错误的结果为范围广泛的感谢值以加重在数字固有的不精确性(0.5650.5751.005),我可以建议在再次寻找这个答案,这让他们正确吗?
TJ Crowder

也许你想包括JavaScript中的sprintf库stackoverflow.com/questions/610406/...
蒂洛

在使用小数位移位和舍入方法正确舍入后,可以使用该number.toFixed(x)方法将其转换为具有所需数量零的字符串。例如1.341.3使用跨浏览器方法四舍五入,然后添加1个零并使用1.3.toFixed(2)(转换为"1.30")转换为字符串。
爱德华

Answers:


998

要使用定点表示法格式化数字,可以简单地使用toFixed方法:

(10.8).toFixed(2); // "10.80"

var num = 2.4;
alert(num.toFixed(2)); // "2.40"

请注意,toFixed()返回一个字符串。

重要说明:请注意,toFixed不会在90%的时间内舍入,它会返回舍入后的值,但是在许多情况下,它不起作用。

例如:

2.005.toFixed(2) === "2.00"

更新:

现在,您可以使用Intl.NumberFormat构造函数。它是ECMAScript国际化API规范(ECMA402)的一部分。它具有很好的浏览器支持,甚至包括IE11,并且Node.js完全支持它。

const formatter = new Intl.NumberFormat('en-US', {
   minimumFractionDigits: 2,      
   maximumFractionDigits: 2,
});

console.log(formatter.format(2.005)); // "2.01"
console.log(formatter.format(1.345)); // "1.35"

您也可以使用toLocaleString方法,该方法将在内部使用IntlAPI:

const format = (num, decimals) => num.toLocaleString('en-US', {
   minimumFractionDigits: 2,      
   maximumFractionDigits: 2,
});


console.log(format(2.005)); // "2.01"
console.log(format(1.345)); // "1.35"

该API还为您提供了多种格式选项,例如千位分隔符,货币符号等。


17
并非在所有浏览器(0.09).toFixed(1);
均能

41
固定不舍入,您可以先这样做:(Math.round(0.09))。toFixed(1);
rekans 2012年

32
@rekans:这是错误的。Math.Round(0.09)将会回来,0所以这将永远给0.0...
克里斯

28
在大多数情况下,这是一个坏主意,在某些情况下会将数字转换为字符串或浮点数。
灰蓝色

80
必须在这里与@AshBlue达成共识...这仅适用于格式化值的表示形式。可能会因进一步计算而破坏代码。否则Math.round(value*100)/100对于2DP效果更好。
2012年

98

这是一个古老的话题,但仍是Google排名最高的结果,提供的解决方案也存在相同的浮点小数问题。这是我使用的(非常通用的)函数,这要感谢MDN

function round(value, exp) {
  if (typeof exp === 'undefined' || +exp === 0)
    return Math.round(value);

  value = +value;
  exp = +exp;

  if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0))
    return NaN;

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

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

如我们所见,我们没有遇到以下问题:

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

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

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

各种示例和测试(感谢@ tj-crowder!):


1
有没有简单的方法可以做到这一点?ES6可以救援吗?
zero_cool

感谢您发布MDN polyfill。在链接的MDN页面上,polyfill不再存在。我不知道为什么要删除它……
霍莉国王

43

我通常将其添加到我的个人库中,在提出一些建议并也使用@TIMINeutron解决方案之后,使其适用于十进制长度,这是最合适的:

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

将适用于所报告的异常。


2
precision_round(1.275,2)是1.27?
allenhwkim 2013年

2
@Imre将返回值更改为(Math.round(num * Math.pow(10,decimals))/ Math.pow(10,decimals))。toFixed(2); 而且您将不再遇到该问题。
dkroy

6
如果您选择了第二个函数,那么在哪里声明“ sign”和“ dec”呢?
阿迪·恩戈姆

2
我已在IE中为误签方法添加了一个workarround:gist.github.com/ArminVieweg/28647e735aa6efaba401
Armin

1
@Armin您的修复程序也使其可以在Safari中工作。原始功能在Safari中不起作用。
戴夫

19

我不知道为什么不能在以前的答案中添加评论(也许我是无可救药的盲人,不知道),但是我想出了一个使用@Miguel答案的解决方案:

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

及其两个注释(来自@bighostkim和@Imre):

  • precise_round(1.275,2)无法返回1.28的问题
  • precise_round(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添加到已填充的数字上,因此它在十进制值的右边添加了13 0s。因此使用起来应该安全。

之后,我添加了 .toFixed(decimal)为始终以正确的格式输出数字(正确的小数位数)。

就是这样。很好地使用它;)

编辑:为负数的“更正”添加了功能。


2
“更正” 大部分是安全的,但是例如precise_round(1.27499,2)现在也返回1.28 Math.round。计算机内部存储浮点值的方式是。基本上,您注定要在数据到达功能之前就失败一些值:)
Imre 2013年

@Imre,您绝对正确。这就是为什么我要解释这0.001的原因,以防万一有人想使其更“ 精确 ”甚至删除它(如果您碰巧拥有一台每浮点数2 MB的超级计算机,那么我认为这里没有人这样做) ;)
tfrascaroli

1
实际上,语言规范对于使用64位作为数字值非常具体,因此拥有/使用超级计算机不会有任何改变:)
Imre 2013年

对于0.001,您可以根据小数位数的长度添加多个零来进行替换。等等
Miguel

15

一种获得100%确定带有2个小数的数字的方法:

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

如果这导致舍入错误,则可以使用James在其评论中解释的以下内容:

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

6
这是最好,最简单的方法。但是,由于浮点运算的原因,因此1.275 * 100 = 127.49999999999999,这可能会导致舍入中的较小错误。为了解决这个问题,我们可以乘以1000,再除以10,如(1.275 * 1000)/ 10 = 127.5。如下: var answer = (Math.round((num * 1000)/10)/100).toFixed(2);
James Gould

(Math.round((1.015 * 1000)/ 10)/ 100).toFixed(2)仍为1.01,不是1.02吗?
gaurav5430 '19

14

toFixed(n)提供小数点后的n个长度;toPrecision(x)提供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);

它不能正常工作...对于数字num = 50.2349,您应该写信给Precision(3)以获得50.2
PiotrCzyż2014年

这只是一个示例,您可以根据需要进行更改@PiotrCzyż–
Syed Umar Ahmed

5

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

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

例子:

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

// This may produce different results depending on the browser environment
console.log("342.055.toFixed(2)         :", 342.055.toFixed(2)); // 342.06 on Chrome & IE10

console.log("inprecise_round(342.055, 2):", inprecise_round(342.055, 2)); // 342.05
console.log("precise_round(342.055, 2)  :", precise_round(342.055, 2));   // 342.06
console.log("precise_round(-342.055, 2) :", precise_round(-342.055, 2));  // -342.06

console.log("inprecise_round(0.565, 2)  :", inprecise_round(0.565, 2));   // 0.56
console.log("precise_round(0.565, 2)    :", precise_round(0.565, 2));     // 0.57


2
谢谢。这是一个测试的小技巧jsfiddle.net/lamarant/ySXuF。我将toFixed()应用于返回值之前的值,该值将正确数量的零附加到返回值的末尾。
lamarant 2013年

对于value = 0,004990845956707237不起作用,inprecise_round(value,8)返回0,00499085,但必须返回0,00499084
MERTDOĞAN18年

3

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

您可以尝试下一个:

的HTML

<input type="text" name="one" class="two-digits"><br>
<input type="text" name="two" class="two-digits">​

jQuery的

// apply the two-digits behaviour to elements with 'two-digits' as their class
$( function() {
    $('.two-digits').keyup(function(){
        if($(this).val().indexOf('.')!=-1){         
            if($(this).val().split(".")[1].length > 2){                
                if( isNaN( parseFloat( this.value ) ) ) return;
                this.value = parseFloat(this.value).toFixed(2);
            }  
         }            
         return this; //for chaining
    });
});

网上演示:

http://jsfiddle.net/c4Wqn/


1
我可以感谢您的贡献,尽管我认为将DOM元素和jQuery添加到混合中似乎超出了问题的范围。
克里斯,

您不应该收听keyup事件,因为它看起来非常糟糕,并且在您使用脚本添加内容时不会激活。我宁愿听input事件。当您使用JS访问该字段时,这不会产生闪烁效果,而且也会触发
Le'nton 2015年

3

浮点值的问题在于它们试图用固定数量的位表示无限数量的(连续)值。因此,自然而然地,一定会有一些损失,而您会被一些价值所困扰。

当计算机将1.275存储为浮点值时,它实际上将不记得它是1.275还是1.27499999999999993,甚至是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));

请注意,此函数四舍五入为最接近零的关系,而IEEE 754建议将四舍五入为最接近的关系,作为浮点运算的默认行为。这些修改留给读者练习:)


3

这是一个简单的

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

使用方式 alert(roundFloat(1.79209243929,4));

Jsfiddle


2

四舍五入您的十进制值,然后使用toFixed(x)您的期望数字。

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

呼叫

parseDecimalRoundAndFixed(10.800243929,4)=> 10.80 parseDecimalRoundAndFixed(10.807243929,2)=> 10.81


2

四舍五入

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

合并https://stackoverflow.com/a/7641824/1889449https://www.kirupa.com/html5/rounding_numbers_in_javascript.htm,谢谢。


2

/**
 * MidpointRounding away from zero ('arithmetic' rounding)
 * Uses a half-epsilon for correction. (This offsets IEEE-754
 * half-to-even rounding that was applied at the edge cases).
 */

function RoundCorrect(num, precision = 2) {
	// half epsilon to correct edge cases.
	var c = 0.5 * Number.EPSILON * num;
//	var p = Math.pow(10, precision); //slow
	var p = 1; while (precision--> 0) p *= 10;
	if (num < 0)
		p *= -1;
	return Math.round((num + c) * p) / p;
}

// testing some +ve edge cases
console.log(RoundCorrect(1.005, 2));  // 1.01 correct
console.log(RoundCorrect(2.175, 2));  // 2.18 correct
console.log(RoundCorrect(5.015, 2));  // 5.02 correct

// testing some -ve edge cases
console.log(RoundCorrect(-1.005, 2));  // -1.01 correct
console.log(RoundCorrect(-2.175, 2));  // -2.18 correct
console.log(RoundCorrect(-5.015, 2));  // -5.02 correct


2

这是我的一线解决方案: Number((yourNumericValueHere).toFixed(2));

这是发生了什么:

1)首先,将.toFixed(2)您要套用的数字四舍五入到小数点后一位。请注意,这会将值转换为数字的字符串。因此,如果您使用的是Typescript,它将引发如下错误:

“类型'字符串'不可分配给类型'数字'”

2)要取回数值或将字符串转换为数值,只需应用 Number()函数所谓的“字符串”值即可。

为了澄清起见,请看下面的示例:

示例: 我的金额在小数点后最多5位,我想将其缩短到小数点后2位。我这样做是这样的:

var price = 0.26453;
var priceRounded = Number((price).toFixed(2));
console.log('Original Price: ' + price);
console.log('Price Rounded: ' + priceRounded);


1

以下内容放在全局范围内:

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

再试试

var a = 56.23232323;
a.getDecimals(2); // will return 56.23

更新资料

请注意,toFixed()只能使用介于之间的小数位数,0-20a.getDecimals(25)可能会产生JavaScript错误,因此为了适应您可以添加一些额外的检查,即

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

1
Number(((Math.random() * 100) + 1).toFixed(2))

这将返回从1到100的随机数,四舍五入到小数点后2位。



1

通过引用使用此响应:https : //stackoverflow.com/a/21029698/454827

我建立了一个获取动态小数位数的函数:

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

这里的工作示例:https : //jsfiddle.net/wpxLduLc/


1

parse = function (data) {
       data = Math.round(data*Math.pow(10,2))/Math.pow(10,2);
       if (data != null) {
            var lastone = data.toString().split('').pop();
            if (lastone != '.') {
                 data = parseFloat(data);
            }
       }
       return data;
  };

$('#result').html(parse(200)); // output 200
$('#result1').html(parse(200.1)); // output 200.1
$('#result2').html(parse(200.10)); // output 200.1
$('#result3').html(parse(200.109)); // output 200.11
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js"></script>
<div id="result"></div>
<div id="result1"></div>
<div id="result2"></div>
<div id="result3"></div>


1

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

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

1

几个月前,我从这篇文章中得到了一些想法,但是这里没有答案,也没有其他帖子/博客的答案可以解决所有情况(例如,测试人员发现的负数和一些“幸运数字”)。最后,我们的测试人员在下面的此方法中未发现任何问题。粘贴我的代码片段:

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

0

我解决了修饰符的问题。 仅支持2个小数。

$(function(){
  //input number only.
  convertNumberFloatZero(22); // output : 22.00
  convertNumberFloatZero(22.5); // output : 22.50
  convertNumberFloatZero(22.55); // output : 22.55
  convertNumberFloatZero(22.556); // output : 22.56
  convertNumberFloatZero(22.555); // output : 22.55
  convertNumberFloatZero(22.5541); // output : 22.54
  convertNumberFloatZero(22222.5541); // output : 22,222.54

  function convertNumberFloatZero(number){
	if(!$.isNumeric(number)){
		return 'NaN';
	}
	var numberFloat = number.toFixed(3);
	var splitNumber = numberFloat.split(".");
	var cNumberFloat = number.toFixed(2);
	var cNsplitNumber = cNumberFloat.split(".");
	var lastChar = splitNumber[1].substr(splitNumber[1].length - 1);
	if(lastChar > 0 && lastChar < 5){
		cNsplitNumber[1]--;
	}
	return Number(splitNumber[0]).toLocaleString('en').concat('.').concat(cNsplitNumber[1]);
  };
});
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>


0
(Math.round((10.2)*100)/100).toFixed(2)

那应该产生: 10.20

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

那应该产生: 0.05

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

那应该产生: 4.04

等等


0

/*Due to all told stuff. You may do 2 things for different purposes:
When showing/printing stuff use this in your alert/innerHtml= contents:
YourRebelNumber.toFixed(2)*/

var aNumber=9242.16;
var YourRebelNumber=aNumber-9000;
alert(YourRebelNumber);
alert(YourRebelNumber.toFixed(2));

/*and when comparing use:
Number(YourRebelNumber.toFixed(2))*/

if(YourRebelNumber==242.16)alert("Not Rounded");
if(Number(YourRebelNumber.toFixed(2))==242.16)alert("Rounded");

/*Number will behave as you want in that moment. After that, it'll return to its defiance.
*/


0

这非常简单,并且与其他任何方法一样有效:

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

由于toFixed()只能在数字上调用,并且不幸地返回一个字符串,因此这将为您完成双向的所有解析。您可以传递一个字符串或一个数字,每次都可以返回一个数字!调用parseNumber(1.49)将给您1,而parseNumber(1.49,2)将给您1.50。就像他们最好的一样!


0

您还可以使用该 .toPrecision()方法和一些自定义代码,并且始终将其舍入为第n个十进制数字,而不管int部分的长度如何。

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

您还可以使其成为更好使用的插件。



-2

我找到了一种非常简单的方法为我解决了这个问题,可以使用或改编:

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

-4

100%工作!!!尝试一下

<html>
     <head>
      <script>
      function replacePonto(){
        var input = document.getElementById('qtd');
        var ponto = input.value.split('.').length;
        var slash = input.value.split('-').length;
        if (ponto > 2)
                input.value=input.value.substr(0,(input.value.length)-1);

        if(slash > 2)
                input.value=input.value.substr(0,(input.value.length)-1);

        input.value=input.value.replace(/[^0-9.-]/,'');

        if (ponto ==2)
	input.value=input.value.substr(0,(input.value.indexOf('.')+3));

if(input.value == '.')
	input.value = "";
              }
      </script>
      </head>
      <body>
         <input type="text" id="qtd" maxlength="10" style="width:140px" onkeyup="return replacePonto()">
      </body>
    </html>


欢迎来到SO。请阅读此操作方法,然后按照指南进行操作。
thewaywere是
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.