Formatieren Sie die Nummer so, dass immer 2 Dezimalstellen angezeigt werden

Ich möchte meine Zahlen so formatieren, dass immer 2 Dezimalstellen angezeigt werden, gegebenenfalls gerundet.

Beispiele:

number     display
------     -------
1          1.00
1.341      1.34
1.345      1.35

Ich habe dies verwendet:

parseFloat(num).toFixed(2);

Aber es wird angezeigt 1als1 statt 1.00.

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

Live-Demo

var num1 = "1";
document.getElementById('num1').innerHTML = (Math.round(num1 * 100) / 100).toFixed(2);

var num2 = "1.341";
document.getElementById('num2').innerHTML = (Math.round(num2 * 100) / 100).toFixed(2);

var num3 = "1.345";
document.getElementById('num3').innerHTML = (Math.round(num3 * 100) / 100).toFixed(2);

span {
    border: 1px solid #000;
    margin: 5px;
    padding: 5px;
}

<span id="num1"></span>
<span id="num2"></span>
<span id="num3"></span>

Beachten Sie, dass es auf 2 Dezimalstellen gerundet wird , sodass die Eingabe 1.346zurückkehrt 1.35.

Number(1).toFixed(2);         // 1.00
Number(1.341).toFixed(2);     // 1.34
Number(1.345).toFixed(2);     // 1.34 NOTE: See andy's comment below.
Number(1.3450001).toFixed(2); // 1.35

document.getElementById('line1').innerHTML = Number(1).toFixed(2);
document.getElementById('line2').innerHTML = Number(1.341).toFixed(2);
document.getElementById('line3').innerHTML = Number(1.345).toFixed(2);
document.getElementById('line4').innerHTML = Number(1.3450001).toFixed(2);

<span id="line1"></span>
<br/>
<span id="line2"></span>
<br/>
<span id="line3"></span>
<br/>
<span id="line4"></span>

Diese Antwort schlägt fehl, wenn value = 1.005.

Als bessere Lösung kann das Rundungsproblem vermieden werden, indem Zahlen in Exponentialschreibweise verwendet werden:

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

Saubererer Code, wie von @Kon und dem ursprünglichen Autor vorgeschlagen:

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces)

Sie können toFixed()am Ende hinzufügen , um den Dezimalpunkt beizubehalten, z. B.: 1.00Beachten Sie jedoch, dass er als Zeichenfolge zurückgegeben wird.

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces).toFixed(decimalPlaces)

Gutschrift: Runden von Dezimalstellen in JavaScript

var num = new Number(14.12);
console.log(num.toPrecision(2));//outputs 14
console.log(num.toPrecision(3));//outputs 14.1
console.log(num.toPrecision(4));//outputs 14.12
console.log(num.toPrecision(5));//outputs 14.120

Erstellen Sie für die genaueste Rundung diese Funktion:

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

und verwenden Sie es, um auf 2 Dezimalstellen zu runden:

console.log("seeked to " + round(1.005, 2));
> 1.01

Dank Razu , diesem Artikel und der Math.round-Referenz von MDN .

Verwenden Sie für moderne Browser toLocaleString:

var num = 1.345;
num.toLocaleString(undefined, { maximumFractionDigits: 2, minimumFractionDigits: 2 });

Geben Sie ein Gebietsschema-Tag als ersten Parameter an, um das Dezimaltrennzeichen zu steuern . Verwenden Sie für einen Punkt beispielsweise das englische US-Gebietsschema:

num.toLocaleString("en-US", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

was gibt:

1,35

Die meisten Länder in Europa verwenden ein Komma als Dezimaltrennzeichen. Wenn Sie also beispielsweise das Gebietsschema Schwedisch / Schweden verwenden:

num.toLocaleString("sv-SE", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

es wird geben:

1,35

Einfachste Antwort:

var num = 1.2353453;
num.toFixed(2); // 1.24

Beispiel: http://jsfiddle.net/E2XU7/

Eine viel allgemeinere Lösung zum Runden auf N Stellen

function roundN(num,n){
  return parseFloat(Math.round(num * Math.pow(10, n)) /Math.pow(10,n)).toFixed(n);
}


console.log(roundN(1,2))
console.log(roundN(1.34,2))
console.log(roundN(1.35,2))
console.log(roundN(1.344,2))
console.log(roundN(1.345,2))
console.log(roundN(1.344,3))
console.log(roundN(1.345,3))
console.log(roundN(1.3444,3))
console.log(roundN(1.3455,3))

Output

1.00
1.34
1.35
1.34
1.35
1.344
1.345
1.344
1.346

var number = 123456.789;


console.log(new Intl.NumberFormat('en-IN', { maximumFractionDigits: 2 }).format(number));

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat

Wenn Sie jQuery bereits verwenden, können Sie das jQuery-Nummernformat verwenden Plugin .

Das Plugin kann formatierte Zahlen als Zeichenfolge zurückgeben, Sie können Dezimalstellen und Tausende von Trennzeichen festlegen und die Anzahl der anzuzeigenden Dezimalstellen auswählen.

$.number( 123, 2 ); // Returns '123.00'

Sie können das jQuery Number Format auch von GitHub herunterladen .

Ist es das was du meinst?

function showAsFloat(num, n){
      return !isNaN(+num) ? (+num).toFixed(n || 2) : num;
}

document.querySelector('#result').textContent = 
    [
     'command                      | result',
     '-----------------------------------------------',
     'showAsFloat(1);              | ' + showAsFloat(1),
     'showAsFloat(1.314);          | ' + showAsFloat(1.314),
     'showAsFloat(\'notanumber\')    | ' + showAsFloat('notanumber'),
     'showAsFloat(\'23.44567\', 3)   | ' + showAsFloat('23.44567', 3),
     'showAsFloat(2456198, 5)      | ' + showAsFloat('2456198', 5),
     'showAsFloat(0);              | ' + showAsFloat(0)
    ].join('\n');

<pre id="result"></pre>

Konvertieren Sie eine Zahl in eine Zeichenfolge, wobei Sie nur zwei Dezimalstellen beibehalten:

var num = 5.56789;
var n = num.toFixed(2);

Das Ergebnis von n ist:

5.57

Suchen Sie Boden?

var num = 1.42482;
var num2 = 1;
var fnum = Math.floor(num).toFixed(2);
var fnum2 = Math.floor(num2).toFixed(2);
alert(fnum + " and " + fnum2); //both values will be 1.00

function currencyFormat (num) {
    return "$" + num.toFixed(2).replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1,")
}

console.info(currencyFormat(2665));   // $2,665.00
console.info(currencyFormat(102665)); // $102,665.00

Hier ist auch eine generische Funktion, die auf eine beliebige Anzahl von Dezimalstellen formatiert werden kann:

function numberFormat(val, decimalPlaces) {

    var multiplier = Math.pow(10, decimalPlaces);
    return (Math.round(val * multiplier) / multiplier).toFixed(decimalPlaces);
}

Wenn eine bestimmte Formatierung erforderlich ist, sollten Sie Ihre eigene Routine schreiben oder eine Bibliotheksfunktion verwenden, die genau das tut, was Sie benötigen. Die grundlegende ECMAScript-Funktionalität reicht normalerweise nicht aus, um formatierte Zahlen anzuzeigen.

Eine ausführliche Erklärung zum Runden und Formatieren finden Sie hier: http://www.merlyn.demon.co.uk/js-round.htm#RiJ

Rundungen und Formatierungen sollten in der Regel nur als letzter Schritt vor der Ausgabe durchgeführt werden. Wenn Sie dies früher tun, kann dies zu unerwartet großen Fehlern führen und die Formatierung zerstören.

Laufen Sie einfach in diesen längsten Thread, unten ist meine Lösung:

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

Lassen Sie mich wissen, ob jemand ein Loch stechen kann

Sie geben uns nicht das ganze Bild.

javascript:alert(parseFloat(1).toFixed(2))zeigt 1,00 in meinen Browsern an, wenn ich es in die Positionsleiste einfüge. Wenn Sie jedoch danach etwas tun, wird es zurückgesetzt.

var num = 2
document.getElementById('spanId').innerHTML=(parseFloat(num).toFixed(2)-1)


shows 1 and not 1.00

var quantity = 12;

var import1 = 12.55;

var total = quantity * import1;

var answer = parseFloat(total).toFixed(2);

document.write(answer);

Ich musste mich zwischen den Konvertierungen parseFloat () und Number () entscheiden, bevor ich toFixed () aufrufen konnte. Hier ist ein Beispiel für eine Zahlenformatierung nach der Erfassung von Benutzereingaben.

HTML:

<input type="number" class="dec-number" min="0" step="0.01" />

Ereignishandler:

$('.dec-number').on('change', function () {
     const value = $(this).val();
     $(this).val(value.toFixed(2));
});

Der obige Code führt zu einer TypeError-Ausnahme. Beachten Sie, dass der HTML-Eingabetyp zwar "number" ist, die Benutzereingabe jedoch tatsächlich ein "string" -Datentyp ist. Die Funktion toFixed () kann jedoch nur für ein Objekt aufgerufen werden, das eine Zahl ist.

Mein endgültiger Code würde wie folgt aussehen:

$('.dec-number').on('change', function () {
     const value = Number($(this).val());
     $(this).val(value.toFixed(2));
});

Der Grund, warum ich mit Number () vs. parseFloat () umsetze, ist, dass ich weder für eine leere Eingabezeichenfolge noch für einen NaN-Wert eine zusätzliche Validierung durchführen muss. Die Number () -Funktion behandelt automatisch eine leere Zeichenfolge und verdeckt sie auf Null.

Ich mag:

var num = 12.749;
parseFloat((Math.round(num * 100) / 100).toFixed(2)); // 123.75

Runden Sie die Zahl mit 2 Dezimalstellen und stellen Sie sicher, dass Sie sie analysieren parseFloat() , um Number und nicht String zurückzugeben, es sei denn, es ist Ihnen egal, ob es sich um String oder Number handelt.

Extend Math Objekt mit Präzisionsverfahren

Object.defineProperty(Math, 'precision',{
   value: function (value,precision,type){
             var v = parseFloat(value),
                 p = Math.max(precision,0)||0,
                 t = type||'round';
              return (Math[t](v*Math.pow(10,p))/Math.pow(10,p)).toFixed(p);
          }
    });

console.log(
    Math.precision(3.1,3), // round 3 digits 
    Math.precision(0.12345,2,'ceil'), // ceil 2 digits
    Math.precision(1.1) // integer part
)

parseInt(number * 100) / 100; arbeitete für mich.

Hier ist eine andere Lösung, um nur mit Floor zu runden, dh sicherzustellen, dass der berechnete Betrag nicht größer als der ursprüngliche Betrag ist (manchmal für Transaktionen erforderlich):

Math.floor(num* 100 )/100;

Sie können diesen Code ausprobieren:

    function FormatNumber(number, numberOfDigits = 2) {
        try {
            return new Intl.NumberFormat('en-US').format(parseFloat(number).toFixed(2));
        } catch (error) {
            return 0;
        }
    }

    var test1 = FormatNumber('1000000.4444');
    alert(test1); // 1,000,000.44

    var test2 = FormatNumber(100000000000.55555555, 4);
    alert(test2); // 100,000,000,000.56

Versuchen Sie den folgenden Code:

function numberWithCommas(number) { 

   var newval = parseFloat(Math.round(number * 100) / 100).toFixed(2);

   return newval.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}

(num + "").replace(/^([0-9]*)(\.[0-9]{1,2})?.*$/,"$1$2")

So löse ich mein Problem:

parseFloat(parseFloat(floatString).toFixed(2));