我有这行代码将我的数字四舍五入到小数点后两位。但我得到这样的数字：10.8、2.4 等。这些不是我的小数点后两位的想法，所以我该如何改进以下内容？
Math.round(price*Math.pow(10,2))/Math.pow(10,2);
我想要 10.80、2.40 等数字。我可以使用 jQuery。
问问题
850449 次
31 回答
1108
要使用定点表示法格式化数字，您可以简单地使用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 还为您提供了多种格式选项，例如千位分隔符、货币符号等。
于 2009-11-13T02:02:17.033 回答
110
这是一个古老的话题，但仍然在谷歌搜索结果中名列前茅，并且提供的解决方案共享相同的浮点小数问题。这是我使用的（非常通用的）函数，感谢 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！）：
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));
}
function naive(value, exp) {
if (!exp) {
return Math.round(value);
}
var pow = Math.pow(10, exp);
return Math.round(value * pow) / pow;
}
function test(val, places) {
subtest(val, places);
val = typeof val === "string" ? "-" + val : -val;
subtest(val, places);
}
function subtest(val, places) {
var placesOrZero = places || 0;
var naiveResult = naive(val, places);
var roundResult = round(val, places);
if (placesOrZero >= 0) {
naiveResult = naiveResult.toFixed(placesOrZero);
roundResult = roundResult.toFixed(placesOrZero);
} else {
naiveResult = naiveResult.toString();
roundResult = roundResult.toString();
}
$("<tr>")
.append($("<td>").text(JSON.stringify(val)))
.append($("<td>").text(placesOrZero))
.append($("<td>").text(naiveResult))
.append($("<td>").text(roundResult))
.appendTo("#results");
}
test(0.565, 2);
test(0.575, 2);
test(0.585, 2);
test(1.275, 2);
test(1.27499, 2);
test(1234.5678, -2);
test(1.2345678e+2, 2);
test("123.45");
test(10.8034, 2);
test(10.8, 2);
test(1.005, 2);
test(1.0005, 2);table {
border-collapse: collapse;
}
table, td, th {
border: 1px solid #ddd;
}
td, th {
padding: 4px;
}
th {
font-weight: normal;
font-family: sans-serif;
}
td {
font-family: monospace;
}<table>
<thead>
<tr>
<th>Input</th>
<th>Places</th>
<th>Naive</th>
<th>Thorough</th>
</tr>
</thead>
<tbody id="results">
</tbody>
</table>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>于 2014-01-24T02:31:08.643 回答
45
我通常将它添加到我的个人库中，经过一些建议并使用@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);
}
将适用于报告的异常。
于 2013-02-12T18:58:47.027 回答
18
我不知道为什么我不能在以前的答案中添加评论（也许我是盲目的，我不知道），但我想出了一个使用@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 个s。0所以使用起来应该是安全的。
之后，我添加.toFixed(decimal)始终以正确的格式输出数字（使用正确的小数位数）。
差不多就是这样。好好利用它；）
编辑：为负数的“更正”添加了功能。
于 2013-05-01T14:18:53.197 回答
17
一种 100% 确定您得到 2 位小数的方法的方法：
(Math.round(num*100)/100).toFixed(2)
如果这导致舍入错误，您可以使用 James 在他的评论中解释的以下内容：
(Math.round((num * 1000)/10)/100).toFixed(2)
于 2014-01-09T19:45:40.617 回答
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);
于 2012-04-17T07:34:59.133 回答
9
快速简单
parseFloat(number.toFixed(2))
例子
let number = 2.55435930
let roundedString = number.toFixed(2) // "2.55"
let twoDecimalsNumber = parseFloat(roundedString) // 2.55
let directly = parseFloat(number.toFixed(2)) // 2.55
于 2021-01-28T23:01:38.700 回答
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于 2013-04-29T09:38:57.003 回答
4
这是一个简单的
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));
于 2014-01-02T14:48:44.780 回答
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
});
});
在线演示：
于 2012-11-27T17:42:13.300 回答
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建议四舍五入到最接近，甚至作为浮点运算的默认行为。这些修改留给读者作为练习:)
于 2013-08-07T12:49:04.627 回答
3
向下舍入
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/1889449和 https://www.kirupa.com/html5/rounding_numbers_in_javascript.htm谢谢他们。
于 2018-01-28T13:34:34.550 回答
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
于 2014-11-07T05:03:11.030 回答
2
Number(Math.round(1.005+'e2')+'e-2'); // 1.01
这对我有用：在 JavaScript 中舍入小数
于 2015-03-13T15:37:44.823 回答
2
这是我的 1 行解决方案：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);于 2018-04-25T05:08:45.310 回答
2
在Christian C. Salvadó's answer 的基础上，执行以下操作将输出一个Number类型，并且似乎也可以很好地处理四舍五入：
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()你在使用它时不需要链接[，并且它输出一个Number类型]。
于 2021-05-12T19:56:31.037 回答
2
通常，小数舍入是通过缩放完成的：round(num * p) / p
幼稚的实现
使用以下带有中间数字的函数，您将获得预期的上舍入值，或者有时取决于输入的下舍入值。
这种inconsistency舍入可能会在客户端代码中引入难以检测的错误。
function naiveRound(num, decimalPlaces) {
var p = Math.pow(10, decimalPlaces);
return Math.round(num * p) / p;
}
console.log( naiveRound(1.245, 2) ); // 1.25 correct (rounded as expected)
console.log( naiveRound(1.255, 2) ); // 1.25 incorrect (should be 1.26)更好的实现
通过将数字转换为指数符号中的字符串，正数按预期四舍五入。但是，请注意负数与正数的舍入方式不同。
事实上，它执行的规则基本上相当于“四舍五入”，您会看到即使round(-1.005, 2)评估为 ，也会评估为。lodash _.round方法使用了这种技术。-1round(1.005, 2)1.01
/**
* Round half up ('round half towards positive infinity')
* Uses exponential notation to avoid floating-point issues.
* Negative numbers round differently than positive numbers.
*/
function round(num, decimalPlaces) {
num = Math.round(num + "e" + decimalPlaces);
return Number(num + "e" + -decimalPlaces);
}
// test rounding of half
console.log( round(0.5, 0) ); // 1
console.log( round(-0.5, 0) ); // 0
// testing edge cases
console.log( round(1.005, 2) ); // 1.01
console.log( round(2.175, 2) ); // 2.18
console.log( round(5.015, 2) ); // 5.02
console.log( round(-1.005, 2) ); // -1
console.log( round(-2.175, 2) ); // -2.17
console.log( round(-5.015, 2) ); // -5.01如果在舍入负数时想要通常的行为，则需要在调用Math.round()之前将负数转换为正数，然后在返回之前将它们转换回负数。
// Round half away from zero
function round(num, decimalPlaces) {
num = Math.round(Math.abs(num) + "e" + decimalPlaces) * Math.sign(num);
return Number(num + "e" + -decimalPlaces);
}
有一种不同的纯数学技术来执行舍入到最近（使用“离零的一半”），其中在调用舍入函数之前应用epsilon 校正。
简单地说，我们在四舍五入之前将可能的最小浮点值（= 1.0 ulp；最后一个单位）添加到数字。这将移动到数字之后的下一个可表示值，远离零。
/**
* Round half away from zero ('commercial' rounding)
* Uses correction to offset floating-point inaccuracies.
* Works symmetrically for positive and negative numbers.
*/
function round(num, decimalPlaces) {
var p = Math.pow(10, decimalPlaces);
var e = Number.EPSILON * num * p;
return Math.round((num * p) + e) / p;
}
// test rounding of half
console.log( round(0.5, 0) ); // 1
console.log( round(-0.5, 0) ); // -1
// testing edge cases
console.log( round(1.005, 2) ); // 1.01
console.log( round(2.175, 2) ); // 2.18
console.log( round(5.015, 2) ); // 5.02
console.log( round(-1.005, 2) ); // -1.01
console.log( round(-2.175, 2) ); // -2.18
console.log( round(-5.015, 2) ); // -5.02这是为了抵消在十进制数编码期间可能出现的隐式舍入误差，尤其是在最后一个小数位具有“5”的数字，如 1.005、2.675 和 16.235。实际上，1.005在十进制系统中被编码为1.004999999999999964 位二进制浮点数；而1234567.005在十进制系统中编码为1234567.004999999888241364 位二进制浮点数。
值得注意的是，最大二进制round-off error取决于 (1) 数字的大小和 (2) 相对机器 epsilon (2^-52)。
于 2018-02-18T11:05:30.140 回答
2
使用这些示例，您在尝试将数字 1.005 舍入时仍然会出现错误，解决方案是使用 Math.js 之类的库或此函数：
function round(value: number, decimals: number) {
return Number(Math.round(value + 'e' + decimals) + 'e-' + decimals);
}
于 2018-02-09T23:09:57.740 回答
1
将以下内容放在某个全局范围内：
Number.prototype.getDecimals = function ( decDigCount ) {
return this.toFixed(decDigCount);
}
然后尝试：
var a = 56.23232323;
a.getDecimals(2); // will return 56.23
更新
请注意，仅适用于ietoFixed()之间的小数位数可能会生成 javascript 错误，因此为了适应您可以添加一些额外的检查 ie0-20a.getDecimals(25)
Number.prototype.getDecimals = function ( decDigCount ) {
return ( decDigCount > 20 ) ? this : this.toFixed(decDigCount);
}
于 2014-07-16T07:13:05.767 回答
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/
于 2016-11-11T14:51:36.433 回答
1
Number(((Math.random() * 100) + 1).toFixed(2))
这将返回一个从 1 到 100 的随机数，四舍五入到小数点后 2 位。
于 2015-11-20T20:24:35.437 回答
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).
于 2018-09-24T06:30:21.237 回答
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>于 2017-03-23T14:06:05.490 回答
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
等等
于 2015-03-26T21:32:08.460 回答
0
您也可以使用该 .toPrecision()方法和一些自定义代码，并且无论 int 部分的长度如何，始终向上舍入到第 n 个十进制数字。
function glbfrmt (number, decimals, seperator) {
return typeof number !== 'number' ? number : number.toPrecision( number.toString().split(seperator)[0].length + decimals);
}
您也可以将其作为插件更好地使用。
于 2016-10-04T11:59:10.677 回答
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>于 2015-07-20T06:16:24.800 回答
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.
*/于 2016-01-15T20:07:21.027 回答
0
这是https://stackoverflow.com/a/21323330/916734的 TypeScript 实现。它还通过函数使事情变得干燥，并允许可选的数字偏移量。
export function round(rawValue: number | string, precision = 0, fractionDigitOffset = 0): number | string {
const value = Number(rawValue);
if (isNaN(value)) return rawValue;
precision = Number(precision);
if (precision % 1 !== 0) return NaN;
let [ stringValue, exponent ] = scientificNotationToParts(value);
let shiftExponent = exponentForPrecision(exponent, precision, Shift.Right);
const enlargedValue = toScientificNotation(stringValue, shiftExponent);
const roundedValue = Math.round(enlargedValue);
[ stringValue, exponent ] = scientificNotationToParts(roundedValue);
const precisionWithOffset = precision + fractionDigitOffset;
shiftExponent = exponentForPrecision(exponent, precisionWithOffset, Shift.Left);
return toScientificNotation(stringValue, shiftExponent);
}
enum Shift {
Left = -1,
Right = 1,
}
function scientificNotationToParts(value: number): Array<string> {
const [ stringValue, exponent ] = value.toString().split('e');
return [ stringValue, exponent ];
}
function exponentForPrecision(exponent: string, precision: number, shift: Shift): number {
precision = shift * precision;
return exponent ? (Number(exponent) + precision) : precision;
}
function toScientificNotation(value: string, exponent: number): number {
return Number(`${value}e${exponent}`);
}
于 2020-06-15T20:01:27.203 回答
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。就像他们中最好的一样！
于 2016-05-19T21:07:50.360 回答
-3
我找到了一种非常简单的方法可以为我解决这个问题并且可以使用或改编：
td[row].innerHTML = price.toPrecision(price.toFixed(decimals).length
于 2018-11-16T13:38:43.547 回答
-5
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>于 2017-05-05T20:24:48.173 回答