Auf höchstens 2 Dezimalstellen runden (nur bei Bedarf)

Ich möchte höchstens 2 Dezimalstellen runden, aber nur bei Bedarf .

Eingang:

10
1.7777777
9.1

Ausgabe:

10
1.78
9.1

Wie kann ich das in JavaScript machen?

Verwenden Math.round(num * 100) / 100

Bearbeiten: Um sicherzustellen, dass Dinge wie 1.005 richtig sind, verwenden wir

Math.round((num + Number.EPSILON) * 100) / 100

Wenn der Wert ein Texttyp ist:

parseFloat("123.456").toFixed(2);

Wenn der Wert eine Zahl ist:

var numb = 123.23454;
numb = numb.toFixed(2);

Es gibt einen Nachteil, dass Werte wie 1,5 "1,50" als Ausgabe ergeben. Ein von @minitech vorgeschlagener Fix:

var numb = 1.5;
numb = +numb.toFixed(2);
// Note the plus sign that drops any "extra" zeroes at the end.
// It changes the result (which is a string) into a number again (think "0 + foo"),
// which means that it uses only as many digits as necessary.

Es scheint Math.roundeine bessere Lösung zu sein. Aber es ist nicht! In einigen Fällen wird es NICHT richtig gerundet:

Math.round(1.005 * 1000)/1000 // Returns 1 instead of expected 1.01!

toFixed () rundet in einigen Fällen auch NICHT richtig (getestet in Chrome v.55.0.2883.87)!

Beispiele:

parseFloat("1.555").toFixed(2); // Returns 1.55 instead of 1.56.
parseFloat("1.5550").toFixed(2); // Returns 1.55 instead of 1.56.
// However, it will return correct result if you round 1.5551.
parseFloat("1.5551").toFixed(2); // Returns 1.56 as expected.

1.3555.toFixed(3) // Returns 1.355 instead of expected 1.356.
// However, it will return correct result if you round 1.35551.
1.35551.toFixed(2); // Returns 1.36 as expected.

Ich denke, das liegt daran, dass 1.555 tatsächlich so etwas wie Float 1.55499994 hinter den Kulissen ist.

Lösung 1 besteht darin, ein Skript mit dem erforderlichen Rundungsalgorithmus zu verwenden, zum Beispiel:

function roundNumber(num, scale) {
  if(!("" + num).includes("e")) {
    return +(Math.round(num + "e+" + scale)  + "e-" + scale);
  } else {
    var arr = ("" + num).split("e");
    var sig = ""
    if(+arr[1] + scale > 0) {
      sig = "+";
    }
    return +(Math.round(+arr[0] + "e" + sig + (+arr[1] + scale)) + "e-" + scale);
  }
}

https://plnkr.co/edit/uau8BlS1cqbvWPCHJeOy?p=preview

HINWEIS: Dies ist keine universelle Lösung für alle. Es gibt verschiedene Rundungsalgorithmen. Ihre Implementierung kann je nach Ihren Anforderungen unterschiedlich sein. https://en.wikipedia.org/wiki/Rounding

Lösung 2 besteht darin, Front-End-Berechnungen zu vermeiden und gerundete Werte vom Back-End-Server abzurufen.

Sie können verwenden

function roundToTwo(num) {    
    return +(Math.round(num + "e+2")  + "e-2");
}

Ich fand das vorbei MDN gefunden . Ihr Weg vermeidet das erwähnte Problem mit 1.005 .

roundToTwo(1.005)
1.01
roundToTwo(10)
10
roundToTwo(1.7777777)
1.78
roundToTwo(9.1)
9.1
roundToTwo(1234.5678)
1234.57

MarkGs Antwort ist die richtige. Hier ist eine generische Erweiterung für eine beliebige Anzahl von Dezimalstellen.

Number.prototype.round = function(places) {
  return +(Math.round(this + "e+" + places)  + "e-" + places);
}

Verwendungszweck:

var n = 1.7777;    
n.round(2); // 1.78

Gerätetest:

it.only('should round floats to 2 places', function() {

  var cases = [
    { n: 10,      e: 10,    p:2 },
    { n: 1.7777,  e: 1.78,  p:2 },
    { n: 1.005,   e: 1.01,  p:2 },
    { n: 1.005,   e: 1,     p:0 },
    { n: 1.77777, e: 1.8,   p:1 }
  ]

  cases.forEach(function(testCase) {
    var r = testCase.n.round(testCase.p);
    assert.equal(r, testCase.e, 'didn\'t get right number');
  });
})

Du solltest benutzen:

Math.round( num * 100 + Number.EPSILON ) / 100

Niemand scheint sich dessen bewusst zu sein Number.EPSILON .

Es ist auch erwähnenswert, dass dies keine JavaScript-Verrücktheit ist, wie einige Leute sagten.

So funktionieren Gleitkommazahlen in einem Computer einfach. Wie 99% der Programmiersprachen verfügt JavaScript nicht über hausgemachte Gleitkommazahlen. Dafür ist die CPU / FPU erforderlich. Ein Computer verwendet Binärdateien, und in Binärdateien gibt es keine Zahlen wie0.1 , sondern nur eine binäre Näherung dafür. Warum? Aus dem gleichen Grund kann 1/3 nicht dezimal geschrieben werden: Der Wert ist 0,33333333 ... mit einer Unendlichkeit von drei.

Hier komm Number.EPSILON. Diese Zahl ist die Differenz zwischen 1 und der nächsten Zahl, die in den Gleitkommazahlen mit doppelter Genauigkeit vorhanden ist. Das war's: Es gibt keine Zahl zwischen 1und 1 + Number.EPSILON.

BEARBEITEN:

Lassen Sie uns, wie in den Kommentaren gefragt, eines klarstellen: Hinzufügen Number.EPSILON ist nur relevant, wenn der zu runde Wert das Ergebnis einer arithmetischen Operation ist, da es ein Gleitkomma-Fehlerdelta verschlucken kann.

Dies ist nicht sinnvoll, wenn der Wert aus einer direkten Quelle stammt (z. B. Literal, Benutzereingabe oder Sensor).

EDIT (2019):

Wie @maganap und einige Leute bereits betont haben, ist es am besten, Number.EPSILONvor dem Multiplizieren Folgendes hinzuzufügen :

Math.round( ( num + Number.EPSILON ) * 100 ) / 100

EDIT (Dezember 2019):

In letzter Zeit verwende ich eine ähnliche Funktion zum Vergleichen von epsilon-fähigen Zahlen:

const ESPILON_RATE = 1 + Number.EPSILON ;
const ESPILON_ZERO = Number.MIN_VALUE ;

function epsilonEquals( a , b ) {
  if ( Number.isNaN( a ) || Number.isNaN( b ) ) {
    return false ;
  }
  if ( a === 0 || b === 0 ) {
    return a <= b + EPSILON_ZERO && b <= a + EPSILON_ZERO ;
  }
  return a <= b * EPSILON_RATE && b <= a * EPSILON_RATE ;
}

Mein Anwendungsfall ist eine Behauptung + Datenvalidierungsbibliothek, die ich seit vielen Jahren entwickle.

In dem Code, den ich verwende, ESPILON_RATE = 1 + 4 * Number.EPSILONund EPSILON_ZERO = 4 * Number.MIN_VALUE(viermal das Epsilon), weil ich möchte, dass ein Gleichheitsprüfer locker genug ist, um Gleitkommafehler zu kumulieren.

Bisher sieht es für mich perfekt aus. Ich hoffe es wird helfen.

Man kann verwenden .toFixed(NumberOfDecimalPlaces).

var str = 10.234.toFixed(2); // => '10.23'
var number = Number(str); // => 10.23

Diese Frage ist kompliziert.

Angenommen, wir haben eine Funktion, roundTo2DP(num)die ein Gleitkomma als Argument verwendet und einen auf 2 Dezimalstellen gerundeten Wert zurückgibt. Wofür sollte jeder dieser Ausdrücke ausgewertet werden?

• roundTo2DP(0.014999999999999999)
• roundTo2DP(0.0150000000000000001)
• roundTo2DP(0.015)

Die 'offensichtliche' Antwort ist, dass das erste Beispiel auf 0,01 runden sollte (weil es näher an 0,01 als an 0,02 liegt), während die anderen beiden auf 0,02 runden sollten (weil 0,0150000000000000001 näher an 0,02 als an 0,01 liegt und weil 0,015 genau in der Mitte liegt sie und es gibt eine mathematische Konvention, dass solche Zahlen aufgerundet werden).

Der Haken, den Sie vielleicht erraten haben, ist, dass er roundTo2DP möglicherweise nicht implementiert werden kann, um diese offensichtlichen Antworten zu geben, da alle drei an ihn übergebenen Zahlen dieselbe Zahl sind . IEEE 754-Binärgleitkommazahlen (die von JavaScript verwendete Art) können die meisten nicht ganzzahligen Zahlen nicht genau darstellen. Daher werden alle drei oben genannten numerischen Literale auf eine nahegelegene gültige Gleitkommazahl gerundet. Diese Zahl ist zufällig genau

0.01499999999999999944488848768742172978818416595458984375

das ist näher an 0,01 als an 0,02.

Sie können sehen, dass alle drei Zahlen in Ihrer Browserkonsole, Node-Shell oder einem anderen JavaScript-Interpreter gleich sind. Vergleichen Sie sie einfach:

> 0.014999999999999999 === 0.0150000000000000001
true

Wenn ich also schreibe m = 0.0150000000000000001, ist der genaue Wertm , mit dem ich ende, näher 0.01als er ist 0.02. Und doch, wenn ich min einen String konvertiere ...

> var m = 0.0150000000000000001;
> console.log(String(m));
0.015
> var m = 0.014999999999999999;
> console.log(String(m));
0.015

... Ich bekomme 0,015, was auf 0,02 runden sollte und was merklich nicht die 56-Dezimalstellen-Zahl ist, von der ich zuvor gesagt habe, dass alle diese Zahlen genau gleich sind. Was für eine dunkle Magie ist das?

Die Antwort finden Sie in der ECMAScript-Spezifikation in Abschnitt 7.1.12.1: ToString, angewendet auf den Nummerntyp . Hier werden die Regeln für die Konvertierung einer Zahl m in einen String festgelegt. Der Schlüsselteil ist Punkt 5, in dem eine ganze Zahl s erzeugt wird, deren Ziffern in der String-Darstellung von m verwendet werden :

lassen n , k und s ganze Zahlen , so dass k ≥ 1, 10 ^{k -1} ≤ s <10 ^k , der Zahlenwert für s 10 × ^{n - k} ist m , und k ist so klein wie möglich. Es ist zu beachten, dass k die Anzahl der Stellen in der Dezimaldarstellung von s ist , dass s nicht durch 10 teilbar ist und dass die niedrigstwertige Ziffer von s durch diese Kriterien nicht unbedingt eindeutig bestimmt wird.

Der Schlüsselteil hier ist die Anforderung, dass " k so klein wie möglich ist". Was die Forderung beläuft sich auf eine Anforderung , dass eine Nummer m, den Wert String(m)muss eine möglichst geringe Anzahl von Stellen , während immer noch die Anforderung erfüllt , dass Number(String(m)) === m. Da wir das bereits wissen 0.015 === 0.0150000000000000001, ist jetzt klar, warum String(0.0150000000000000001) === '0.015'das wahr sein muss.

Natürlich hat keine dieser Diskussionen direkt beantwortet, was zurückkehren roundTo2DP(m) sollte . Wenn mder genaue Wert 0.01499999999999999944488848768742172978818416595458984375 ist, die Zeichenfolgendarstellung jedoch '0.015' lautet, was ist dann die richtige Antwort - mathematisch, praktisch, philosophisch oder was auch immer -, wenn wir sie auf zwei Dezimalstellen runden?

Darauf gibt es keine einzige richtige Antwort. Dies hängt von Ihrem Anwendungsfall ab. Sie möchten wahrscheinlich die Zeichenfolgendarstellung respektieren und nach oben runden, wenn:

• Der dargestellte Wert ist von Natur aus diskret, z. B. ein Währungsbetrag in einer Währung mit 3 Dezimalstellen wie Dinar. In diesem Fall wird der wahre Wert einer Zahl wie 0,015 ist 0,015, und die 0,0149999999 ... Darstellung , dass es in binärer Gleitkomma- erhält , ist ein Rundungsfehler. (Natürlich werden viele vernünftigerweise argumentieren, dass Sie eine Dezimalbibliothek für die Behandlung solcher Werte verwenden und sie niemals als binäre Gleitkommazahlen darstellen sollten.)
• Der Wert wurde von einem Benutzer eingegeben. Auch in diesem Fall ist die genaue eingegebene Dezimalzahl "wahr" als die nächste binäre Gleitkommadarstellung.

Auf der anderen Seite möchten Sie wahrscheinlich den binären Gleitkommawert berücksichtigen und nach unten runden, wenn Ihr Wert von einer inhärent kontinuierlichen Skala stammt - beispielsweise wenn es sich um einen Messwert von einem Sensor handelt.

Diese beiden Ansätze erfordern unterschiedlichen Code. Um die String-Darstellung der Zahl zu respektieren, können wir (mit ziemlich viel subtilem Code) unsere eigene Rundung implementieren, die direkt auf die String-Darstellung wirkt, Ziffer für Ziffer, wobei wir denselben Algorithmus verwenden, den Sie in der Schule verwendet hätten, als Sie wurden gelehrt, wie man Zahlen rundet. Im Folgenden finden Sie ein Beispiel, das die Anforderung des OP berücksichtigt, die Zahl "nur bei Bedarf" auf 2 Dezimalstellen darzustellen, indem nach dem Dezimalpunkt nachgestellte Nullen entfernt werden. Möglicherweise müssen Sie es natürlich an Ihre genauen Bedürfnisse anpassen.

/**
 * Converts num to a decimal string (if it isn't one already) and then rounds it
 * to at most dp decimal places.
 *
 * For explanation of why you'd want to perform rounding operations on a String
 * rather than a Number, see http://stackoverflow.com/a/38676273/1709587
 *
 * @param {(number|string)} num
 * @param {number} dp
 * @return {string}
 */
function roundStringNumberWithoutTrailingZeroes (num, dp) {
    if (arguments.length != 2) throw new Error("2 arguments required");

    num = String(num);
    if (num.indexOf('e+') != -1) {
        // Can't round numbers this large because their string representation
        // contains an exponent, like 9.99e+37
        throw new Error("num too large");
    }
    if (num.indexOf('.') == -1) {
        // Nothing to do
        return num;
    }

    var parts = num.split('.'),
        beforePoint = parts[0],
        afterPoint = parts[1],
        shouldRoundUp = afterPoint[dp] >= 5,
        finalNumber;

    afterPoint = afterPoint.slice(0, dp);
    if (!shouldRoundUp) {
        finalNumber = beforePoint + '.' + afterPoint;
    } else if (/^9+$/.test(afterPoint)) {
        // If we need to round up a number like 1.9999, increment the integer
        // before the decimal point and discard the fractional part.
        finalNumber = Number(beforePoint)+1;
    } else {
        // Starting from the last digit, increment digits until we find one
        // that is not 9, then stop
        var i = dp-1;
        while (true) {
            if (afterPoint[i] == '9') {
                afterPoint = afterPoint.substr(0, i) +
                             '0' +
                             afterPoint.substr(i+1);
                i--;
            } else {
                afterPoint = afterPoint.substr(0, i) +
                             (Number(afterPoint[i]) + 1) +
                             afterPoint.substr(i+1);
                break;
            }
        }

        finalNumber = beforePoint + '.' + afterPoint;
    }

    // Remove trailing zeroes from fractional part before returning
    return finalNumber.replace(/0+$/, '')
}

Anwendungsbeispiel:

> roundStringNumberWithoutTrailingZeroes(1.6, 2)
'1.6'
> roundStringNumberWithoutTrailingZeroes(10000, 2)
'10000'
> roundStringNumberWithoutTrailingZeroes(0.015, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.015000', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(1, 1)
'1'
> roundStringNumberWithoutTrailingZeroes('0.015', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(0.01499999999999999944488848768742172978818416595458984375, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.01499999999999999944488848768742172978818416595458984375', 2)
'0.01'

Die obige Funktion ist wahrscheinlich die, die Sie verwenden möchten, um zu vermeiden, dass Benutzer jemals feststellen, dass eingegebene Zahlen falsch gerundet werden.

(Alternativ können Sie auch die round10- Bibliothek ausprobieren, die eine ähnlich verhaltende Funktion mit einer völlig anderen Implementierung bietet.)

Aber was ist, wenn Sie die zweite Art von Zahl haben - einen Wert aus einer kontinuierlichen Skala, bei der es keinen Grund zu der Annahme gibt, dass ungefähre Dezimaldarstellungen mit weniger Dezimalstellen genauer sind als solche mit mehr? In diesem Fall möchten wir die String-Darstellung nicht berücksichtigen, da diese Darstellung (wie in der Spezifikation erläutert) bereits gerundet ist. Wir wollen nicht den Fehler machen, zu sagen "0.014999999 ... 375 rundet auf 0.015, was auf 0.02 rundet, also 0.014999999 ... 375 rundet auf 0.02".

Hier können wir einfach die eingebaute toFixedMethode verwenden. Beachten Sie, dass wir durch Aufrufen Number()des von toFixedzurückgegebenen Strings eine Zahl erhalten, deren String-Darstellung keine nachgestellten Nullen enthält (dank der Art und Weise, wie JavaScript die String-Darstellung einer Zahl berechnet, die weiter oben in dieser Antwort erläutert wurde).

/**
 * Takes a float and rounds it to at most dp decimal places. For example
 *
 *     roundFloatNumberWithoutTrailingZeroes(1.2345, 3)
 *
 * returns 1.234
 *
 * Note that since this treats the value passed to it as a floating point
 * number, it will have counterintuitive results in some cases. For instance,
 * 
 *     roundFloatNumberWithoutTrailingZeroes(0.015, 2)
 *
 * gives 0.01 where 0.02 might be expected. For an explanation of why, see
 * http://stackoverflow.com/a/38676273/1709587. You may want to consider using the
 * roundStringNumberWithoutTrailingZeroes function there instead.
 *
 * @param {number} num
 * @param {number} dp
 * @return {number}
 */
function roundFloatNumberWithoutTrailingZeroes (num, dp) {
    var numToFixedDp = Number(num).toFixed(dp);
    return Number(numToFixedDp);
}

Betrachten Sie .toFixed()und .toPrecision():

http://www.javascriptkit.com/javatutors/formatnumber.shtml

Eine präzise Rundungsmethode. Quelle: Mozilla

(function(){

    /**
     * Decimal adjustment of a number.
     *
     * @param   {String}    type    The type of adjustment.
     * @param   {Number}    value   The number.
     * @param   {Integer}   exp     The exponent (the 10 logarithm of the adjustment base).
     * @returns {Number}            The adjusted value.
     */
    function decimalAdjust(type, value, exp) {
        // If the exp is undefined or zero...
        if (typeof exp === 'undefined' || +exp === 0) {
            return Math[type](value);
        }
        value = +value;
        exp = +exp;
        // If the value is not a number or the exp is not an integer...
        if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
            return NaN;
        }
        // Shift
        value = value.toString().split('e');
        value = Math[type](+(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));
    }

    // Decimal round
    if (!Math.round10) {
        Math.round10 = function(value, exp) {
            return decimalAdjust('round', value, exp);
        };
    }
    // Decimal floor
    if (!Math.floor10) {
        Math.floor10 = function(value, exp) {
            return decimalAdjust('floor', value, exp);
        };
    }
    // Decimal ceil
    if (!Math.ceil10) {
        Math.ceil10 = function(value, exp) {
            return decimalAdjust('ceil', value, exp);
        };
    }
})();

Beispiele:

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
Math.round10(1.005, -2); // 1.01 -- compare this with Math.round(1.005*100)/100 above
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50

Keine der hier gefundenen Antworten ist richtig . @stinkycheeseman gebeten, runden , Sie alle Zahl gerundet.

Verwenden Sie zum Aufrunden Folgendes:

Math.ceil(num * 100)/100;

Hier ist eine einfache Möglichkeit, dies zu tun:

Math.round(value * 100) / 100

Möglicherweise möchten Sie jedoch eine separate Funktion erstellen, um dies für Sie zu tun:

function roundToTwo(value) {
    return(Math.round(value * 100) / 100);
}

Dann würden Sie einfach den Wert übergeben.

Sie können es auf eine beliebige Anzahl von Dezimalstellen runden, indem Sie einen zweiten Parameter hinzufügen.

function myRound(value, places) {
    var multiplier = Math.pow(10, places);

    return (Math.round(value * multiplier) / multiplier);
}

+(10).toFixed(2); // = 10
+(10.12345).toFixed(2); // = 10.12

(10).toFixed(2); // = 10.00
(10.12345).toFixed(2); // = 10.12

Für mich gab Math.round () keine richtige Antwort. Ich fand, dass Fixed (2) besser funktioniert. Nachfolgend finden Sie Beispiele für beides:

console.log(Math.round(43000 / 80000) * 100); // wrong answer

console.log(((43000 / 80000) * 100).toFixed(2)); // correct answer

Verwenden Sie diese Funktion Number(x).toFixed(2);

2017
Verwenden Sie einfach nativen Code.toFixed()

number = 1.2345;
number.toFixed(2) // "1.23"

Wenn Sie streng sein und bei Bedarf Ziffern hinzufügen müssen, kann dies verwendet werden replace

number = 1; // "1"
number.toFixed(5).replace(/\.?0*$/g,'');

Probieren Sie diese leichte Lösung aus:

function round(x, digits){
  return parseFloat(x.toFixed(digits))
}

 round(1.222,  2) ;
 // 1.22
 round(1.222, 10) ;
 // 1.222

Es gibt verschiedene Möglichkeiten, dies zu tun. Für Leute wie mich die Lodash-Variante

function round(number, precision) {
    var pair = (number + 'e').split('e')
    var value = Math.round(pair[0] + 'e' + (+pair[1] + precision))
    pair = (value + 'e').split('e')
    return +(pair[0] + 'e' + (+pair[1] - precision))
}

Verwendungszweck:

round(0.015, 2) // 0.02
round(1.005, 2) // 1.01

Wenn Ihr Projekt jQuery oder lodash verwendet, finden Sie die richtige roundMethode auch in den Bibliotheken.

Update 1

Ich habe die Variante entfernt n.toFixed(2), weil sie nicht korrekt ist. Vielen Dank an avalanche1

Wenn Sie die lodash-Bibliothek verwenden, können Sie die runde Methode von lodash wie folgt verwenden.

_.round(number, precision)

Z.B:

_.round(1.7777777, 2) = 1.78

Seit ES6 gibt es eine "richtige" Möglichkeit (ohne Statik zu überschreiben und Problemumgehungen zu erstellen), dies mithilfe von toPrecision zu tun

var x = 1.49999999999;
console.log(x.toPrecision(4));
console.log(x.toPrecision(3));
console.log(x.toPrecision(2));

var y = Math.PI;
console.log(y.toPrecision(6));
console.log(y.toPrecision(5));
console.log(y.toPrecision(4));

var z = 222.987654
console.log(z.toPrecision(6));
console.log(z.toPrecision(5));
console.log(z.toPrecision(4));

dann können Sie einfach parseFloatund Nullen werden "verschwinden".

console.log(parseFloat((1.4999).toPrecision(3)));
console.log(parseFloat((1.005).toPrecision(3)));
console.log(parseFloat((1.0051).toPrecision(3)));

Das '1.005-Rundungsproblem' wird dadurch jedoch nicht gelöst, da es wesentlich dazu beiträgt, wie Float-Brüche verarbeitet werden .

console.log(1.005 - 0.005);

Wenn Sie für Bibliotheken geöffnet sind, können Sie bignumber.js verwenden

console.log(1.005 - 0.005);
console.log(new BigNumber(1.005).minus(0.005));

console.log(new BigNumber(1.005).round(4));
console.log(new BigNumber(1.005).round(3));
console.log(new BigNumber(1.005).round(2));
console.log(new BigNumber(1.005).round(1));

<script src="https://cdnjs.cloudflare.com/ajax/libs/bignumber.js/2.3.0/bignumber.min.js"></script>

MarkG und Lavamantis boten eine viel bessere Lösung als die akzeptierte. Es ist eine Schande, dass sie nicht mehr positive Stimmen bekommen!

Hier ist die Funktion, mit der ich die Gleitkomma-Dezimalstellen-Probleme löse, die auch auf MDN basieren . Es ist noch allgemeiner (aber weniger prägnant) als die Lösung von Lavamantis:

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

Verwenden Sie es mit:

round(10.8034, 2);      // Returns 10.8
round(1.275, 2);        // Returns 1.28
round(1.27499, 2);      // Returns 1.27
round(1.2345678e+2, 2); // Returns 123.46

Im Vergleich zu Lavamantis 'Lösung können wir ...

round(1234.5678, -2); // Returns 1200
round("123.45");      // Returns 123

Dies kann Ihnen helfen:

var result = Math.round(input*100)/100;

Weitere Informationen finden Sie unter diesem Link

Math.round (num) vs num.toFixed (0) und Browser-Inkonsistenzen

Der einfachste Ansatz wäre, toFixed zu verwenden und dann nachfolgende Nullen mit der Number-Funktion zu entfernen:

const number = 15.5;
Number(number.toFixed(2)); // 15.5

const number = 1.7777777;
Number(number.toFixed(2)); // 1.78

var roundUpto = function(number, upto){
    return Number(number.toFixed(upto));
}
roundUpto(0.1464676, 2);

toFixed(2) hier ist 2 die Anzahl der Stellen, bis zu denen wir diese Zahl runden möchten.

Es kann für Sie arbeiten,

Math.round(num * 100)/100;

den Unterschied zwischen toFixed und round kennen. Sie können sich Math.round (num) vs num.toFixed (0) und Browser-Inkonsistenzen ansehen .

Einfachster Weg:

+num.toFixed(2)

Es konvertiert es in einen String und dann zurück in eine Ganzzahl / Float.

Hier ist eine Prototypmethode:

Number.prototype.round = function(places){
    places = Math.pow(10, places); 
    return Math.round(this * places)/places;
}

var yournum = 10.55555;
yournum = yournum.round(2);

Verwenden Sie so etwas wie "parseFloat (parseFloat (value) .toFixed (2))"

parseFloat(parseFloat("1.7777777").toFixed(2))-->1.78 
parseFloat(parseFloat("10").toFixed(2))-->10 
parseFloat(parseFloat("9.1").toFixed(2))-->9.1

Eine Möglichkeit, eine solche Rundung nur bei Bedarf zu erreichen , ist die Verwendung von Number.prototype.toLocaleString () :

myNumber.toLocaleString('en', {maximumFractionDigits:2, useGrouping:false})

Dies liefert genau die Ausgabe, die Sie erwarten, jedoch als Zeichenfolgen. Sie können diese weiterhin in Zahlen konvertieren, wenn dies nicht der erwartete Datentyp ist.

Nach Durchlaufen verschiedener Iterationen aller möglichen Möglichkeiten, um eine wirklich genaue Dezimalrundungsgenauigkeit zu erzielen, ist es klar, dass die genaueste und effizienteste Lösung die Verwendung von Number.EPSILON ist. Dies bietet eine echte mathematische Lösung für das Problem der mathematischen Genauigkeit von Gleitkommazahlen. Es kann wie hier gezeigt einfach polyfilliert werden: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON , um alle letzten verbleibenden IE-Benutzer zu unterstützen (dann vielleicht auch wir sollte damit aufhören).

Angepasst an die hier bereitgestellte Lösung: https://stackoverflow.com/a/48850944/6910392

Eine einfache Drop-In-Lösung, die eine genaue Dezimalrundung, Bodenbelag und Decke mit einer optionalen Präzisionsvariablen bietet, ohne eine ganze Bibliothek hinzuzufügen.

UPDATE: Wie Sergey in den Kommentaren feststellte, gibt es eine Einschränkung für diese (oder jede andere) Methode, auf die hingewiesen werden sollte. Bei Zahlen wie 0.0149999999999999999 treten immer noch Ungenauigkeiten auf, die darauf zurückzuführen sind, dass die absolute Grenze der Genauigkeitsbeschränkungen für die Speicherung von Gleitkommawerten erreicht wurde. Es gibt keine mathematische oder andere Lösung, die angewendet werden kann, um dies zu berücksichtigen, da der Wert selbst sofort als 0,015 ausgewertet wird. Sie können dies bestätigen, indem Sie diesen Wert einfach selbst in der Konsole aufrufen. Aufgrund dieser Einschränkung wäre es nicht einmal möglich, die Zeichenfolgenmanipulation zu verwenden, um diesen Wert zu reduzieren, da die Zeichenfolgendarstellung einfach "0,015" ist. Jede Lösung, um dies zu berücksichtigen, müsste logisch an der Datenquelle angewendet werden, bevor der Wert jemals in ein Skript übernommen wird.

var DecimalPrecision = (function(){
        if (Number.EPSILON === undefined) {
            Number.EPSILON = Math.pow(2, -52);
        }
        this.round = function(n, p=2){
            let r = 0.5 * Number.EPSILON * n;
            let o = 1; while(p-- > 0) o *= 10;
            if(n < 0)
                o *= -1;
            return Math.round((n + r) * o) / o;
        }
        this.ceil = function(n, p=2){
            let r = 0.5 * Number.EPSILON * n;
            let o = 1; while(p-- > 0) o *= 10;
            if(n < 0)
                o *= -1;
            return Math.ceil((n + r) * o) / o;
        }
        this.floor = function(n, p=2){
            let r = 0.5 * Number.EPSILON * n;
            let o = 1; while(p-- > 0) o *= 10;
            if(n < 0)
                o *= -1;
            return Math.floor((n + r) * o) / o;
        }
        return this;
    })();
    console.log(DecimalPrecision.round(1.005));
    console.log(DecimalPrecision.ceil(1.005));
    console.log(DecimalPrecision.floor(1.005));
    console.log(DecimalPrecision.round(1.0049999));
    console.log(DecimalPrecision.ceil(1.0049999));
    console.log(DecimalPrecision.floor(1.0049999));
    console.log(DecimalPrecision.round(2.175495134384,7));
    console.log(DecimalPrecision.round(2.1753543549,8));
    console.log(DecimalPrecision.round(2.1755465135353,4));

Dies ist die einfachste und eleganteste Lösung (und ich bin der Beste der Welt;):

function roundToX(num, X) {    
    return +(Math.round(num + "e+"+X)  + "e-"+X);
}
//roundToX(66.66666666,2) => 66.67
//roundToX(10,2) => 10
//roundToX(10.904,2) => 10.9