Javascript: Formatieren einer gerundeten Zahl auf N Dezimalstellen

In JavaScript ist die typische Methode zum Runden einer Zahl auf N Dezimalstellen wie folgt:

function roundNumber(num, dec) {
  return Math.round(num * Math.pow(10, dec)) / Math.pow(10, dec);
}

function roundNumber(num, dec) {
  return Math.round(num * Math.pow(10, dec)) / Math.pow(10, dec);
}

console.log(roundNumber(0.1 + 0.2, 2));
console.log(roundNumber(2.1234, 2));

Dieser Ansatz wird jedoch auf maximal N Dezimalstellen gerundet, während ich immer auf N Dezimalstellen runden möchte . Zum Beispiel würde "2.0" auf "2" gerundet.

Irgendwelche Ideen?

Das ist kein Rundungsproblem, das ist ein Anzeigeproblem. Eine Zahl enthält keine Informationen zu signifikanten Ziffern. Der Wert 2 entspricht 2.0000000000000. Wenn Sie den gerundeten Wert in eine Zeichenfolge umwandeln, wird eine bestimmte Anzahl von Ziffern angezeigt.

Sie können einfach Nullen nach der Zahl einfügen, etwa:

var s = number.toString();
if (s.indexOf('.') == -1) s += '.';
while (s.length < s.indexOf('.') + 4) s += '0';

(Beachten Sie, dass dies voraussetzt, dass die regionalen Einstellungen des Clients Punkt als Dezimaltrennzeichen verwenden. Der Code benötigt etwas mehr Arbeit, um für andere Einstellungen zu funktionieren.)

Ich denke, dass es einen einfacheren Ansatz für alle hier gegebenen gibt und die Methode Number.toFixed()bereits in JavaScript implementiert ist.

schreibe einfach:

var myNumber = 2;

myNumber.toFixed(2); //returns "2.00"
myNumber.toFixed(1); //returns "2.0"

etc...

Ich habe einen Weg gefunden. Dies ist Christophs Code mit einem Fix:

function toFixed(value, precision) {
    var precision = precision || 0,
        power = Math.pow(10, precision),
        absValue = Math.abs(Math.round(value * power)),
        result = (value < 0 ? '-' : '') + String(Math.floor(absValue / power));

    if (precision > 0) {
        var fraction = String(absValue % power),
            padding = new Array(Math.max(precision - fraction.length, 0) + 1).join('0');
        result += '.' + padding + fraction;
    }
    return result;
}

Lesen Sie hier die Details zum Wiederholen eines Zeichens mit einem Array-Konstruktor , wenn Sie neugierig sind, warum ich "+ 1" hinzugefügt habe.

Es gibt immer einen besseren Weg, um Dinge zu tun.

var number = 51.93999999999761;

Ich möchte eine Genauigkeit von vier Stellen erhalten: 51,94

mach einfach:

number.toPrecision(4);

Das Ergebnis ist: 51,94

PHP-ähnliche Rundungsmethode

Mit dem folgenden Code können Sie Ihre eigene Version von Math.round zu Ihrem eigenen Namespace hinzufügen, der einen Präzisionsparameter verwendet. Im Gegensatz zur Dezimalrundung im obigen Beispiel führt dies keine Konvertierung in und von Zeichenfolgen durch, und der Genauigkeitsparameter funktioniert genauso wie PHP und Excel, wobei eine positive 1 auf 1 Dezimalstelle und -1 auf die Zehner gerundet wird.

var myNamespace = {};
myNamespace.round = function(number, precision) {
    var factor = Math.pow(10, precision);
    var tempNumber = number * factor;
    var roundedTempNumber = Math.round(tempNumber);
    return roundedTempNumber / factor;
};

myNamespace.round(1234.5678, 1); // 1234.6
myNamespace.round(1234.5678, -1); // 1230

von Mozilla Developer Referenz für Math.round ()

Hoffentlich funktionierender Code (hat nicht viel getestet):

function toFixed(value, precision) {
    var precision = precision || 0,
        neg = value < 0,
        power = Math.pow(10, precision),
        value = Math.round(value * power),
        integral = String((neg ? Math.ceil : Math.floor)(value / power)),
        fraction = String((neg ? -value : value) % power),
        padding = new Array(Math.max(precision - fraction.length, 0) + 1).join('0');

    return precision ? integral + '.' +  padding + fraction : integral;
}

Ich denke unten Funktion kann helfen

function roundOff(value,round) {
   return (parseInt(value * (10 ** (round + 1))) - parseInt(value * (10 ** round)) * 10) > 4 ? (((parseFloat(parseInt((value + parseFloat(1 / (10 ** round))) * (10 ** round))))) / (10 ** round)) : (parseFloat(parseInt(value * (10 ** round))) / ( 10 ** round));
}

Verwendung: roundOff(600.23458,2);wird zurückkehren600.23

Dies funktioniert zum Runden auf N Ziffern (wenn Sie nur auf N Ziffern kürzen möchten, entfernen Sie den Aufruf Math.round und verwenden Sie den Aufruf Math.trunc):

function roundN(value, digits) {
   var tenToN = 10 ** digits;
   return /*Math.trunc*/(Math.round(value * tenToN)) / tenToN;
}

Ich musste in der Vergangenheit bei Java auf diese Logik zurückgreifen, als ich E-Slate-Komponenten für die Datenmanipulation verfasste . Das liegt daran, dass ich herausgefunden hatte, dass das mehrfache Hinzufügen von 0,1 zu 0 zu einem unerwartet langen Dezimalteil führen würde (dies liegt an der Gleitkomma-Arithmetik).

Ein Benutzerkommentar unter Formatnummer, bei dem immer 2 Dezimalstellen angezeigt werden, ruft diese Technikskalierung auf.

Einige erwähnen, dass es Fälle gibt, die nicht wie erwartet runden, und unter http://www.jacklmoore.com/notes/rounding-in-javascript/ wird stattdessen Folgendes vorgeschlagen:

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

Wenn Sie sich nicht wirklich für das Runden interessieren, fügen Sie einfach ein toFixed (x) hinzu und entfernen Sie gegebenenfalls nachfolgende 0en und den Punkt. Es ist keine schnelle Lösung.

function format(value, decimals) {
    if (value) {
        value = value.toFixed(decimals);            
    } else {
        value = "0";
    }
    if (value.indexOf(".") < 0) { value += "."; }
    var dotIdx = value.indexOf(".");
    while (value.length - dotIdx <= decimals) { value += "0"; } // add 0's

    return value;
}