Formatieren einer Zahl mit genau zwei Dezimalstellen in JavaScript
https://stackoverflow.com/questions/1726630
-
19-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Ich habe diese Codezeile, die meine Zahlen auf zwei Dezimalstellen rundet.Aber ich bekomme Zahlen wie diese:10,8, 2,4 usw.Das sind nicht meine Vorstellungen von zwei Dezimalstellen. Wie kann ich also Folgendes verbessern?
Math.round(price*Math.pow(10,2))/Math.pow(10,2);
Ich möchte Zahlen wie 10,80, 2,40 usw.Die Verwendung von jQuery ist für mich in Ordnung.
Lösung
Um eine Zahl mit fester Punktnotation zu formatieren, können Sie einfach die verwenden tofixiert Methode:
(10.8).toFixed(2); // "10.80"
var num = 2.4;
alert(num.toFixed(2)); // "2.40"
Beachten Sie, dass toFixed() Gibt eine Zeichenfolge zurück.
WICHTIG: Beachten Sie, dass Tofixed in 90% der Fälle nicht wirklich rund ist, sondern den abgerundeten Wert zurückgibt, aber für viele Fälle funktioniert es nicht tatsächlich. Versuchen Sie dies in Ihrer Konsole:
2.005.toFixed(2)
Sie erhalten die falsche Antwort
Es gibt keine natürliche Möglichkeit, eine Dezimalrundung in JavaScript zu erhalten. Sie benötigen Ihre eigene Polyfill oder verwenden eine Bibliothek. Sie können sich die Polyfill von Mozilla dafür ansehen https://developer.mozilla.org/en-us/docs/web/javascript/reference/global_objects/math/round
Andere Tipps
Dies ist ein altes Thema, aber immer noch erstklassige Google-Ergebnisse und die Lösungen, die das gleiche Problem mit schwimmenden Punkten-Dezimalstellen teilen. Hier ist die (sehr generische) Funktion, die ich verwende, Vielen Dank an 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));
}
Wie wir sehen können, bekommen wir diese Probleme nicht:
round(1.275, 2); // Returns 1.28
round(1.27499, 2); // Returns 1.27
Diese Generalizität bietet auch ein paar coole Sachen:
round(1234.5678, -2); // Returns 1200
round(1.2345678e+2, 2); // Returns 123.46
round("123.45"); // Returns 123
Um die Frage des OP zu beantworten, muss man nun eingeben:
round(10.8034, 2).toFixed(2); // Returns "10.80"
round(10.8, 2).toFixed(2); // Returns "10.80"
Oder für eine prägnantere, weniger generische Funktion:
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);
}
Sie können es mit:
round2Fixed(10.8034); // Returns "10.80"
round2Fixed(10.8); // Returns "10.80"
Verschiedene Beispiele und Tests (dank @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>Normalerweise füge ich dies meiner persönlichen Bibliothek hinzu, und nach einigen Vorschlägen und auch die @timineutron -Lösung und es passt sie für die Dezimallänge an, die dann am besten passt:
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);
}
wird für die gemeldeten Ausnahmen arbeiten.
Ich weiß nicht, warum ich nicht einer früheren Antwort einen Kommentar hinzufügen kann (vielleicht bin ich hoffnungslos blind, nicht nicht), aber ich habe eine Lösung mit der Antwort von @miguel mit der Antwort von @miguel gefunden:
function precise_round(num,decimals) {
return Math.round(num*Math.pow(10, decimals)) / Math.pow(10, decimals);
}
Und seine zwei Kommentare (von @Bighostkim und @imre):
- Problem mit
precise_round(1.275,2)nicht 1,28 zurückgeben - Problem mit
precise_round(6,2)nicht 6.00 zurückkehren (wie er wollte).
Meine endgültige Lösung lautet wie folgt:
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);
}
Wie Sie sehen, musste ich ein bisschen "Korrektur" hinzufügen (es ist nicht das, was es ist, aber da Mathematik.Round verlust ist - können Sie es auf jsfiddle.net überprüfen - dies ist die einzige Möglichkeit, wie ich "reparieren" wusste, wie man "reparieren soll" zu reparieren " " es). Es fügt der bereits gepolsterten Zahl 0,001 hinzu, sodass es a hinzugefügt wird 1 drei 0s rechts vom Dezimalwert. Es sollte also sicher zu bedienen sein.
Danach fügte ich hinzu .toFixed(decimal) Um die Zahl immer im richtigen Format auszugeben (mit der richtigen Anzahl von Dezimalstellen).
Das ist also so ziemlich es. Benutze es gut;)
Bearbeiten: Funktionalität der "Korrektur" negativer Zahlen hinzugefügt.
Eine Möglichkeit, zu 100% sicher zu sein, dass Sie eine Zahl mit 2 Dezimalstellen erhalten:
(Math.round(num*100)/100).toFixed(2)
Wenn dies Rundungsfehler verursacht, können Sie Folgendes verwenden, wie James in seinem Kommentar erklärt hat:
(Math.round((num * 1000)/10)/100).toFixed(2)
Tofixed (n) liefert n Länge nach dem Dezimalpunkt; Toprecision (x) liefert x Gesamtlänge.
Verwenden Sie diese Methode unten
// 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
Und wenn Sie möchten, dass die Nummer festgelegt wird
result = num.toFixed(2);
Ich habe keine genaue Lösung für dieses Problem gefunden, also habe ich meine eigene erstellt:
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;
}
Beispiele:
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@heridev und ich haben eine kleine Funktion in jQuery erstellt.
Sie können es als nächstes versuchen:
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
});
});
Demo online:
Hier ist ein einfacher
function roundFloat(num,dec){
var d = 1;
for (var i=0; i<dec; i++){
d += "0";
}
return Math.round(num * d) / d;
}
Benutze wie alert(roundFloat(1.79209243929,4));
Das Problem mit schwimmenden Punktwerten besteht darin, dass sie versuchen, eine unendliche Menge an (kontinuierlicher) Werten mit einer festen Menge an Bits darzustellen. Natürlich muss es einen gewissen Verlust im Spiel geben, und Sie werden mit einigen Werten gebissen.
Wenn ein Computer 1.275 als schwimmender Punktwert speichert, wird er nicht wirklich daran erinnert, ob es sich um 1.275 oder 1.2749999999999993 oder sogar 1.27500000000000002 handelte. Diese Werte sollten nach dem Abrunden auf zwei Dezimalstellen unterschiedliche Ergebnisse liefern, aber sie werden es nicht tun, da sie für Computer aussehen genauso Nach dem Speichern als schwimmende Punktwerte und es gibt keine Möglichkeit, die verlorenen Daten wiederherzustellen. Weitere Berechnungen werden nur eine solche Ungenauigkeit ansammeln.
Wenn Präzision wichtig ist, müssen Sie von Anfang an schwimmende Punktwerte vermeiden. Die einfachsten Optionen sind zu
- verwenden ein engagierte Bibliothek
- Verwenden Sie Zeichenfolgen zum Speichern und Umgeben der Werte (begleitet von String -Operationen)
- Verwenden Sie Ganzzahlen (z. B. können Sie die Menge an Hundertstel Ihres tatsächlichen Werts umgeben, z. B. Betrag in Cent anstelle von Dollar in Dollar).
Wenn Sie beispielsweise Ganzzahlen verwenden, um die Anzahl der Hundertstel zu speichern, ist die Funktion zum Finden des tatsächlichen Wertes recht einfach:
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));
Mit Saiten brauchen Sie Rundung, aber es ist immer noch überschaubar:
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));
Beachten Sie, dass diese Funktion auf dem nächsten geht, Bindungen von Null entfernt, während IEEE 754 empfiehlt rund auf am nächsten, Krawatten zu gleichmäßiger als Standardverhalten für schwimmende Punktvorgänge. Solche Modifikationen bleiben als Übung für den Leser :)
Runden Sie Ihren Dezimalwert um und verwenden Sie dann toFixed(x) für Ihre erwarteten Ziffer.
function parseDecimalRoundAndFixed(num,dec){
var d = Math.pow(10,dec);
return (Math.round(num * d) / d).toFixed(dec);
}
Anruf
parsedecimalroundandfixed (10.800243929,4) => 10,80 ParsedecimalroundAndfixed (10.807243929,2) => 10,81
/**
* 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 correctHier ist meine 1-Zeilen-Lösung: Number((yourNumericValueHere).toFixed(2));
Hier ist, was passiert:
1) Zunächst bewerben Sie sich .toFixed(2) auf die Nummer, die Sie die Dezimalstellen abrunden möchten. Beachten Sie, dass dies den Wert in eine Zeichenfolge aus der Zahl umwandelt. Wenn Sie also TypeScript verwenden, wirft dies einen solchen Fehler auf:
"Typ 'String' ist nicht zugeordnet, um 'Nummer' einzugeben."
2) Um den numerischen Wert zurückzugewinnen oder die Zeichenfolge in den numerischen Wert umzuwandeln, wenden Sie einfach die an, um die Number() Funktionen auf diesem sogenannten "String" -Wert.
Zur Klarstellung schauen Sie sich das folgende Beispiel an:
BEISPIEL:Ich habe eine Menge, die an den Dezimalstellen bis zu 5 Ziffern hat, und ich möchte sie bis zu 2 Dezimalstellen verkürzen. Ich mache es so:
var price = 0.26453;
var priceRounded = Number((price).toFixed(2));
console.log('Original Price: ' + price);
console.log('Price Rounded: ' + priceRounded);Stellen folgende In einem globalen Bereich:
Number.prototype.getDecimals = function ( decDigCount ) {
return this.toFixed(decDigCount);
}
und dann versuche es:
var a = 56.23232323;
a.getDecimals(2); // will return 56.23
Aktualisieren
Beachten Sie, dass toFixed() kann nur für die Anzahl der Dezimalstellen zwischen funktionieren 0-20 dh a.getDecimals(25) kann einen JavaScript -Fehler generieren, um zu garnerischen
Number.prototype.getDecimals = function ( decDigCount ) {
return ( decDigCount > 20 ) ? this : this.toFixed(decDigCount);
}
Number(((Math.random() * 100) + 1).toFixed(2))
Dadurch wird eine Zufallszahl von 1 bis 100 auf 2 Dezimalstellen zurückgegeben.
Number(Math.round(1.005+'e2')+'e-2'); // 1.01
Das hat für mich funktioniert: Runden Dezimalstellen in JavaScript runden
Verwenden dieser Antwort durch Referenz: https://stackoverflow.com/a/21029698/454827
Ich erstelle eine Funktion, um dynamische Anzahl von Dezimalstellen zu erhalten:
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;
}
Hier Arbeitsbeispiel: https://jsfiddle.net/wpxldulc/
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>Abrunden
function round_down(value, decPlaces) {
return Math.floor(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}
Zusammenfassen
function round_up(value, decPlaces) {
return Math.ceil(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}
Runde am nächsten
function round_nearest(value, decPlaces) {
return Math.round(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}
Zusammengeführt https://stackoverflow.com/a/7641824/1889449 und https://www.kirupa.com/html5/rounding_numbers_in_javascript.htm Danke ihnen.
Mit diesen Beispielen werden Sie beim Versuch, die Nummer 1.005 zu runden, immer noch ein Fehler aufnehmen. Die Lösung besteht darin, entweder eine Bibliothek wie Math.js oder diese Funktion zu verwenden:
function round(value: number, decimals: number) {
return Number(Math.round(value + 'e' + decimals) + 'e-' + decimals);
}
Ich habe vor ein paar Monaten einige Ideen aus diesem Beitrag erhalten, aber keine der Antworten hier oder Antworten aus anderen Beiträgen/Blogs könnte alle Szenarien bearbeiten (z. B. negative Zahlen und einige "Glückszahlen", die unser Tester gefunden hat). Am Ende fand unser Tester kein Problem mit dieser Methode unten. Einfachen eines Ausschnitts meines Codes:
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));
},
Ich habe auch Code -Kommentare (Entschuldigung, ich habe bereits alle Details vergessen) ... ich poste meine Antwort hier als zukünftige Referenz:
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).
Ich behebe das Problem den Modifikator.Nur 2 dezimal unterstützen.
$(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>(Math.round((10.2)*100)/100).toFixed(2)
Das sollte ausgeben: 10.20
(Math.round((.05)*100)/100).toFixed(2)
Das sollte ausgeben: 0.05
(Math.round((4.04)*100)/100).toFixed(2)
Das sollte ausgeben: 4.04
usw.
/*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.
*/Dies ist sehr einfach und funktioniert genauso gut wie alle anderen:
function parseNumber(val, decimalPlaces) {
if (decimalPlaces == null) decimalPlaces = 0
var ret = Number(val).toFixed(decimalPlaces)
return Number(ret)
}
Da Tofixed () nur auf Zahlen aufgerufen werden kann und leider eine Zeichenfolge zurückgibt, ist dies in beiden Richtungen das gesamte Parsen für Sie. Sie können eine Zeichenfolge oder eine Nummer übergeben, und Sie erhalten jedes Mal eine Nummer zurück! Das Aufrufen von Parsenverumme (1.49) gibt Ihnen 1, und die Parsenberum (1.49,2) gibt Ihnen 1,50. Genau wie das Beste von 'sie!
Sie könnten auch die verwenden .toPrecision() Methode und benutzerdefinierten Code, und runden Sie sich immer auf die n -te Dezimalstelle ab, unabhängig von der Länge des int -Teils.
function glbfrmt (number, decimals, seperator) {
return typeof number !== 'number' ? number : number.toPrecision( number.toString().split(seperator)[0].length + decimals);
}
Sie können es auch zum besseren Gebrauch machen.
Einfach so.
var rounded_value=Math.round(value * 100) / 100;
Ich fand einen sehr einfachen Weg, der dieses Problem für mich gelöst habe und verwendet oder angepasst werden kann:
td[row].innerHTML = price.toPrecision(price.toFixed(decimals).length
100% arbeiten !!! Versuch es
<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>