Eine Zahl mit genau zwei Dezimalstellen in JavaScript formatieren

Dies ist ein altes Thema, aber immer noch Spitzenergebnisse bei Google, und die angebotenen Lösungen haben dasselbe Problem mit der Ausgabe von Gleitkommazahlen. Hier ist die (sehr generische) Funktion, die ich verwende, danke 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, bekommen wir diese Probleme nicht:

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

Diese Generizität bietet auch einige 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 Folgendes 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 anrufen mit:

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

Verschiedene Beispiele und Tests (Danke an @ t-j-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 der Verwendung der @ TIMINeutron-Lösung. Damit es für die Dezimallänge anpassbar ist, passt diese am besten: 

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

funktioniert für die gemeldeten Ausnahmen.

Ich weiß nicht, warum ich nicht zu einer vorherigen Antwort einen Kommentar hinzufügen kann (vielleicht bin ich hoffnungslos blind, keine Ahnung), aber ich habe eine Lösung 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 zurückgegeben 1.28
• Problem mit precise_round(6,2), das nicht 6.00 zurückgibt (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 Math.round verlustbehaftet ist, können Sie es auf jsfiddle.net überprüfen.) "es". Er fügt der bereits aufgefüllten Zahl 0,001 hinzu und fügt rechts vom Dezimalwert einen 1 drei 0s hinzu. Es sollte also sicher zu verwenden sein.

Danach fügte ich .toFixed(decimal) hinzu, um die Zahl immer im richtigen Format auszugeben (mit der richtigen Anzahl Dezimalzahlen).

Das ist so ziemlich alles. Benutze es gut;)

BEARBEITEN: Funktion zur "Korrektur" von negativen Zahlen hinzugefügt.

Eine Möglichkeit, 100% sicher zu sein, dass Sie eine Zahl mit 2 Dezimalstellen erhalten: 

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

Wenn dies zu Rundungsfehlern führt, können Sie Folgendes verwenden, wie James es in seinem Kommentar erklärt hat:

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

toFixed (n) gibt die Länge nach dem Dezimalpunkt an; 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 fix ist

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 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:

http://jsfiddle.net/c4Wqn/

Das Problem bei Gleitkommawerten ist, dass sie versuchen, eine unbegrenzte Anzahl (kontinuierlicher) Werte mit einer festen Anzahl von Bits darzustellen. Natürlich muss es im Spiel einige Verluste geben, und Sie werden mit einigen Werten gebissen werden.

Wenn ein Computer 1,275 als Fließkommawert speichert, kann er sich nicht wirklich daran erinnern, ob er 1,275 oder 1,27499999999999993 oder sogar 1,27500000000000002 war. Diese Werte sollten unterschiedliche Ergebnisse ergeben, nachdem auf zwei Dezimalstellen gerundet wurde. Dies ist jedoch nicht der Fall, da sie nach dem Speichern als Gleitkommawerte genau gleich aussehen, und es gibt keine Möglichkeit, die verlorenen Daten wiederherzustellen. Bei weiteren Berechnungen kommt es nur zu einer solchen Ungenauigkeit.

Wenn es also auf Präzision ankommt, müssen Sie Gleitkommawerte von Anfang an vermeiden. Die einfachsten Optionen sind zu

• benutze eine dedizierte Bibliothek
• verwenden Sie Strings zum Speichern und Weitergeben der Werte (begleitet von Stringoperationen).
• verwenden Sie Ganzzahlen (z. B. können Sie den Betrag von Hundertsteln Ihres tatsächlichen Werts übergeben, z. B. den Betrag in Cent anstelle des Betrags in US-Dollar).

Wenn Sie zum Beispiel die Anzahl der Hundertstel mit Ganzzahlen speichern, ist die Funktion zum Finden des tatsächlichen Werts ziemlich 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));

Bei Strings benötigen Sie eine Rundung, die jedoch noch überschaubar ist:

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 den nächstgelegenen weg von null gerundet wird, [/], während IEEE 754 empfiehlt, auf den nächstgelegenen ties bis even als Standardverhalten für Fließkommaoperationen zu runden. Solche Modifikationen sind für den Leser eine Übung :)

Runden Sie Ihren Dezimalwert auf und verwenden Sie toFixed(x) für Ihre erwarteten Ziffern.

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

Hier ist eine einfache

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

Verwenden Sie wie alert(roundFloat(1.79209243929,4));

Jsfiddle

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ührtes https://stackoverflow.com/a/7641824/1889449 und https://www.kirupa.com/html5/rounding_numbers_in_javascript.htm Danke Sie.

Setzen Sie das Folgende in einem globalen Bereich:

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

und dann probiere :

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

Aktualisieren

Beachten Sie, dass toFixed() nur für die Anzahl der Dezimalstellen zwischen 0-20 funktionieren kann, d. H. a.getDecimals(25) einen Javascript-Fehler generieren kann, so dass Sie zusätzliche Checks hinzufügen können, d.

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

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

Das hat für mich funktioniert: Runden von Dezimalzahlen in JavaScript

Verwenden dieser Antwort als Referenz: https://stackoverflow.com/a/21029698/454827

Ich baue eine Funktion, um dynamische Dezimalzahlen 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/

Ich habe vor ein paar Monaten einige Ideen aus diesem Beitrag erhalten, aber weder die Antworten hier noch die Antworten aus anderen Beiträgen/Blogs konnten alle Szenarien verarbeiten (z. B. negative Zahlen und einige "Glückszahlen", die unser Tester gefunden hat). Letztendlich fand unser Tester mit dieser Methode kein Problem. Einfügen eines Codeausschnitts:

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 hier meine Antwort als 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).

Bei diesen Beispielen wird immer noch ein Fehler angezeigt, wenn Sie versuchen, die Zahl 1.005 zu runden. 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);
}

Hier ist meine 1-Linien-Lösung:Number((yourNumericValueHere).toFixed(2));

Folgendes passiert:

1) Zuerst wenden Sie .toFixed(2) auf die Zahl an, die Sie die Dezimalstellen von runden möchten. Beachten Sie, dass dies den Wert von number in einen String konvertiert. Wenn Sie also TypeScript verwenden, wird ein Fehler wie folgt ausgegeben: 

"Der Typ 'Zeichenfolge' kann nicht dem Typ 'Nummer' zugeordnet werden."

2) Um den numerischen Wert zurückzubekommen oder die Zeichenfolge in einen numerischen Wert umzuwandeln, wenden Sie einfach die Funktion Number() auf diesen sogenannten "Zeichenfolge" -Wert an.

Sehen Sie sich zur Verdeutlichung das folgende Beispiel an:

BEISPIEL: Ich habe einen Betrag mit bis zu 5 Stellen in den Dezimalstellen und möchte ihn auf bis zu 2 Dezimalstellen verkürzen. Ich mache es gerne so:

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

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

dadurch wird eine auf 2 Dezimalstellen gerundete Zufallszahl von 1 bis 100 zurückgegeben.

So einfach ist das.

var rounded_value=Math.round(value * 100) / 100;

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

Das sollte ergeben: 10.20

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

Das sollte ergeben: 0.05

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

Das sollte ergeben: 4.04

usw.

Ich habe einen sehr einfachen Weg gefunden, der dieses Problem für mich gelöst hat und verwendet oder angepasst werden kann:

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

Ich behebe das Problem mit dem Modifikator .Support 2 nur dezimal.

$(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>

Sie können auch die Methode .toPrecision() und einen benutzerdefinierten Code verwenden und unabhängig von der Länge des int-Teils immer auf die n-te Dezimalstelle aufrunden.

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

Sie könnten es auch zu einem Plugin machen, um es besser zu nutzen.

Das ist sehr einfach und funktioniert genauso gut wie die anderen:

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

Da toFixed () nur für Zahlen aufgerufen werden kann und leider einen String zurückgibt, führt dies die gesamte Analyse für Sie in beide Richtungen aus. Sie können eine Zeichenfolge oder eine Zahl übergeben, und Sie erhalten jedes Mal eine Zahl zurück! Wenn Sie parseNumber (1.49) aufrufen, erhalten Sie 1 und parseNumber (1.49,2) 1,50. Genau wie das Beste von ihnen!