数値を小数点以下2桁に丸めるこのコード行があります。しかし、私は次のような数値を取得します：10.8、2.4など。これらは小数点以下2桁の私の考えではないので、どうすれば次のことを改善できますか？
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
これは古いトピックですが、依然としてトップランクの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に感謝します！）：
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);
}
そしてその2つのコメント（@bighostkimと@Imreから）：
precise_round(1.275,2)1.28を返さない問題- 6.00を返さない問題
precise_round(6,2)（彼が望んでいたように）。
私の最終的な解決策は次のとおりです。
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が加算されるため、10進値の右側に13が加算されます。0したがって、安全に使用できるはずです。
その後、.toFixed(decimal)常に正しい形式（正しい小数点以下の桁数）で数値を出力するように追加しました。
これでほぼ完了です。うまく使ってください;）
編集：負の数の「修正」に機能を追加しました。
于 2013-05-01T14:18:53.197 に答える
17
小数点以下2桁の数値を100％確実に取得する1つの方法：
(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であるかを実際には記憶しません。これらの値は、小数点以下2桁に四捨五入した後は異なる結果になるはずですが、コンピューターの場合、浮動小数点値として格納した後はまったく同じように見え、失われたデータを復元する方法がないため、そうではありません。それ以上の計算は、そのような不正確さを蓄積するだけです。
したがって、精度が重要な場合は、最初から浮動小数点値を避ける必要があります。最も簡単なオプションは
- 専用のライブラリを使用する
- 値の格納と受け渡しに文字列を使用する（文字列操作を伴う）
- 整数を使用します（たとえば、実際の値の100分の1の金額を渡すことができます。たとえば、金額をドルではなくセントで渡すことができます）。
たとえば、整数を使用して100分の1の数を格納する場合、実際の値を見つけるための関数は非常に単純です。
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
10進数の値を四捨五入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.005の数値を丸めようとするとエラーが発生します。解決策は、Math.jsなどのライブラリまたは次の関数を使用することです。
function round(value: number, decimals: number) {
return Number(Math.round(value + 'e' + decimals) + 'e-' + decimals);
}
于 2018-02-09T23:09:57.740 に答える
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)と同等のことを実行します。これは、に評価されて-1も、にround(1.005, 2)評価されることがわかります1.01。lodash _.roundメソッドは、この手法を使用します。
/**
* 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);
}
丸め関数を呼び出す前にイプシロン補正が適用される、（「ゼロから半分離れた丸め」を使用して）最も近い丸めを実行するための別の純粋に数学的な手法があります。
単純に、丸める前に、可能な限り最小の浮動小数点値（= 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これは、小数のエンコード中に発生する可能性のある暗黙の丸め誤差、特に1.005、2.675、16.235などの最後の小数位置に「5」があるものを相殺するために必要です。実際、 10進法では、64ビットの2進浮動1.005小数点でエンコードされます。1.0049999999999999一方、 10進法では、64ビットの2進浮動1234567.005小数点でエンコードされます。1234567.0049999998882413
最大バイナリround-off errorは、（1）数値の大きさ、および（2）相対的な計算機イプシロン（2 ^ -52）に依存することに注意してください。
于 2018-02-18T11:05:30.140 に答える
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óの答えに基づいて、次のようにするとタイプが出力さ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 に答える
1
以下をグローバルスコープに入れます。
Number.prototype.getDecimals = function ( decDigCount ) {
return this.toFixed(decDigCount);
}
そして試してみてください：
var a = 56.23232323;
a.getDecimals(2); // will return 56.23
アップデート
toFixed()は、小数点以下の桁数でのみ機能することに注意してください。0-20つまりa.getDecimals(25)、javascriptエラーが生成される可能性があるため、チェックを追加することができます。
Number.prototype.getDecimals = function ( decDigCount ) {
return ( decDigCount > 20 ) ? this : this.toFixed(decDigCount);
}
于 2014-07-16T07:13:05.767 に答える
1
Number(((Math.random() * 100) + 1).toFixed(2))
これにより、小数点以下2桁に丸められた1から100までの乱数が返されます。
于 2015-11-20T20:24:35.437 に答える
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
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 に答える
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 に答える
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
修飾子の問題を修正しました。 小数点以下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
これは非常にシンプルで、他のすべてと同じように機能します。
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 に答える
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
これが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 に答える
-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 に答える