Wie rundet man in Javascript auf 1 Dezimalstelle?

Question

Können Sie eine Zahl in Javascript auf 1 Zeichen nach dem Dezimalpunkt (richtig gerundet) runden?

Ich habe es mit *10, round, /10 versucht, aber es bleiben zwei Dezimalstellen am Ende der int.

Answer 1

Ich stimme für toFixed() aber für das Protokoll, hier ist ein anderer Weg, der Bit-Shifting verwendet, um die Zahl in eine int. Es wird also immer gegen Null gerundet (nach unten für positive Zahlen, nach oben für negative).

var rounded = ((num * 10) << 0) * 0.1;

Aber hey, da es keine Funktionsaufrufe gibt, ist es verdammt schnell :)

Und hier ist eine, die den Abgleich von Zeichenketten verwendet:

var rounded = (num + '').replace(/(^.*?\d+)(\.\d)?.*/, '$1$2');

Ich empfehle nicht, die String-Variante zu verwenden, ich sage es nur.

Answer 2

Im Allgemeinen wird die Dezimalrundung durch Skalierung vorgenommen: round(num * p) / p

Naive Umsetzung

Wenn Sie die folgende Funktion mit halben Zahlen verwenden, erhalten Sie entweder den oberen gerundeten Wert, wie erwartet, oder den unteren gerundeten Wert, je nach Eingabe.

Diese inconsistency bei der Rundung können schwer zu entdeckende Fehler im Client-Code auftreten.

function naiveRound(num, decimalPlaces) {
    var p = Math.pow(10, decimalPlaces);
    return Math.round(num * p) / p;
}

console.log( naiveRound(1.245, 2) );  // 1.25 correct (rounded as expected)
console.log( naiveRound(1.255, 2) );  // 1.25 incorrect (should be 1.26)

Bessere Umsetzungen

Durch die Umwandlung der Zahl in eine Zeichenkette in der Exponentialschreibweise werden positive Zahlen erwartungsgemäß gerundet. Beachten Sie jedoch, dass negative Zahlen anders gerundet werden als positive Zahlen.

Sie führt nämlich etwas aus, das im Grunde genommen gleichbedeutend ist mit "Aufrunden auf die Hälfte" als die Regel, werden Sie sehen, dass round(-1.005, 2) wertet aus zu -1 auch wenn round(1.005, 2) wertet aus zu 1.01 . Die lodash Die Methode _.round verwendet diese Technik.

/**
 * Round half up ('round half towards positive infinity')
 * Uses exponential notation to avoid floating-point issues.
 * Negative numbers round differently than positive numbers.
 */
function round(num, decimalPlaces) {
    num = Math.round(num + "e" + decimalPlaces);
    return Number(num + "e" + -decimalPlaces);
}

// test rounding of half
console.log( round(0.5, 0) );  // 1
console.log( round(-0.5, 0) ); // 0

// testing edge cases
console.log( round(1.005, 2) );   // 1.01
console.log( round(2.175, 2) );   // 2.18
console.log( round(5.015, 2) );   // 5.02

console.log( round(-1.005, 2) );  // -1
console.log( round(-2.175, 2) );  // -2.17
console.log( round(-5.015, 2) );  // -5.01

Wenn Sie das übliche Verhalten beim Runden negativer Zahlen wünschen, müssen Sie negative Zahlen in positive umwandeln, bevor Sie Math.round() und konvertieren sie dann vor der Rückkehr in negative Zahlen zurück.

// Round half away from zero
function round(num, decimalPlaces) {
    num = Math.round(Math.abs(num) + "e" + decimalPlaces) * Math.sign(num);
    return Number(num + "e" + -decimalPlaces);
}

Es gibt eine andere, rein mathematische Technik zur Durchführung von Round-to-Nearest (mit "runde Hälfte von Null weg" ), bei dem Epsilon-Korrektur wird vor dem Aufruf der Rundungsfunktion angewendet.

Wir addieren einfach den kleinstmöglichen Float-Wert (= 1,0 ulp; Einheit an der letzten Stelle) zu der Zahl, bevor wir runden. Dies führt zum nächsten darstellbaren Wert nach der Zahl, weg von Null.

/**
 * Round half away from zero ('commercial' rounding)
 * Uses correction to offset floating-point inaccuracies.
 * Works symmetrically for positive and negative numbers.
 */
function round(num, decimalPlaces) {
    var p = Math.pow(10, decimalPlaces);
    var e = Number.EPSILON * num * p;
    return Math.round((num * p) + e) / p;
}

// test rounding of half
console.log( round(0.5, 0) );  // 1
console.log( round(-0.5, 0) ); // -1

// testing edge cases
console.log( round(1.005, 2) );  // 1.01
console.log( round(2.175, 2) );  // 2.18
console.log( round(5.015, 2) );  // 5.02

console.log( round(-1.005, 2) ); // -1.01
console.log( round(-2.175, 2) ); // -2.18
console.log( round(-5.015, 2) ); // -5.02

Dies ist erforderlich, um die implizite Abrundungsfehler die bei der Kodierung von Dezimalzahlen auftreten können, insbesondere bei solchen mit einer "5" an der letzten Dezimalstelle, wie 1,005, 2,675 und 16,235. Eigentlich, 1.005 im Dezimalsystem wird kodiert zu 1.0049999999999999 in 64-Bit binärem Float; while, 1234567.005 im Dezimalsystem wird kodiert zu 1234567.0049999998882413 in 64-Bit-Binär-Float.

Es ist erwähnenswert, dass die maximale binäre round-off error ist abhängig von (1) der Größe der Zahl und (2) dem relativen Maschinen-Epsilon (2^-52).

Answer 3

Versuchen Sie es hiermit:

var original=28.453

// 1.- round "original" to two decimals
var result = Math.round (original * 100) / 100  //returns 28.45

// 2.- round "original" to 1 decimal
var result = Math.round (original * 10) / 10  //returns 28.5

// 3.- round 8.111111 to 3 decimals
var result = Math.round (8.111111 * 1000) / 1000  //returns 8.111

weniger kompliziert und einfacher zu implementieren...

Damit können Sie eine Funktion erstellen, die Folgendes tut:

function RoundAndFix (n, d) {
    var m = Math.pow (10, d);
    return Math.round (n * m) / m;
}

function RoundAndFix (n, d) {
    var m = Math.pow (10, d);
    return Math.round (n * m) / m;
}
console.log (RoundAndFix(8.111111, 3));

EDIT : siehe dies So runden Sie mit ROUND HALF UP. Der Rundungsmodus, der den meisten von uns in der Grundschule beigebracht wurde

Answer 4

Warum nicht einfach

let myNumber = 213.27321;
+myNumber.toFixed(1); // => 213.3

1. toFixed : gibt eine Zeichenkette zurück, die die angegebene Zahl in Festkomma-Notation darstellt.
2. [Unäres Plus (+)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_plus_()) : Der unäre Plus-Operator geht seinem Operanden voraus und wertet ihn aus, versucht aber, ihn in eine Zahl umzuwandeln, wenn er es nicht schon ist.

Answer 5

var num = 34.7654;

num = Math.round(num * 10) / 10;

console.log(num); // Logs: 34.8