web-dev-qa-db-de.com

Eine Zahl mit genau zwei Dezimalstellen in JavaScript formatieren

Ich habe diese Codezeile, die meine Zahlen auf zwei Dezimalstellen aufrundet. Ich bekomme jedoch Zahlen wie diese: 10.8, 2.4 usw. Dies sind nicht meine Vorstellungen von zwei Dezimalstellen. Wie kann ich die folgenden Werte 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.

531
Abs

Um eine Zahl mit der Festkommanotation zu formatieren, können Sie einfach die Methode toFixed verwenden:

(10.8).toFixed(2); // "10.80"

var num = 2.4;
alert(num.toFixed(2)); // "2.40"

Beachten Sie, dass toFixed() eine Zeichenfolge zurückgibt.

IMPORTANT: Beachten Sie, dass toFixed in 90% der Fälle nicht rundet, sondern den gerundeten Wert zurückgibt, in vielen Fällen jedoch nicht eigentlich arbeiten. Versuchen Sie dies in Ihrer Konsole:

2.005.toFixed(2)

Sie werden die falsche Antwort bekommen

Es gibt keine natürliche Möglichkeit, eine Dezimalrundung in Javascript zu erhalten. Sie benötigen eine eigene Polyfüllung oder verwenden eine Bibliothek. Sie können sich dazu Mozillas Polyfill ansehen https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round

946
CMS

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>

85
astorije

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.

41
Miguel

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.

16
tfrascaroli

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)
13

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);
12
Syed Umar Ahmed

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

5

@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/

3
vicmaster

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

2
Imre

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

2
HATCHA

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

2
ow3n

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.

1
MERT DOĞAN

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);
}
1
Kamran Ahmed
Number(Math.round(1.005+'e2')+'e-2'); // 1.01

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

1
Max G

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/

1
ZiTAL

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>

1
Vishnu T Asok

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).
1
remondo

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);
}
1
David Webster

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

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

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

1
Johnathan Ralls

/**
 * 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 correct

0
Amr Ali

So einfach ist das.

var rounded_value=Math.round(value * 100) / 100;
0
Gihan Gamage
(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.

0
Anthony Ruffino

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
0
IRENE G

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>

0
bamossza

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.

0
leo_lo

/*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.
*/

0

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!

0
Aaron Dake