Wie rundet man in Javascript auf 1 Dezimalstelle?

Antworten:

729

Math.round(num * 10) / 10 funktioniert, hier ist ein Beispiel ...

var number = 12.3456789
var rounded = Math.round(number * 10) / 10
// rounded is 12.3

Wenn Sie möchten, dass es eine Dezimalstelle hat, auch wenn dies eine 0 wäre, fügen Sie ...

var fixed = rounded.toFixed(1)
// fixed is always to 1 d.p.
// NOTE: .toFixed() returns a string!

// To convert back to number format
parseFloat(number.toFixed(2))
// 12.34
// but that will not retain any trailing zeros

// So, just make sure it is the last step before output,
// and use a number format during calculations!

BEARBEITEN: Runde mit Präzisionsfunktion hinzufügen ...

Nach diesem Prinzip dient hier als Referenz eine praktische kleine runde Funktion, die Präzision erfordert ...

function round(value, precision) {
    var multiplier = Math.pow(10, precision || 0);
    return Math.round(value * multiplier) / multiplier;
}

... Verwendungszweck ...

round(12345.6789, 2) // 12345.68
round(12345.6789, 1) // 12345.7

... wird standardmäßig auf die nächste ganze Zahl gerundet (Genauigkeit 0) ...

round(12345.6789) // 12346

... und kann verwendet werden, um auf die nächsten 10 oder 100 usw. zu runden ...

round(12345.6789, -1) // 12350
round(12345.6789, -2) // 12300

... und korrekter Umgang mit negativen Zahlen ...

round(-123.45, 1) // -123.4
round(123.45, 1) // 123.5

... und kann mit toFixed kombiniert werden, um konsistent als Zeichenfolge zu formatieren ...

round(456.7, 2).toFixed(2) // "456.70"
Billy Moon
quelle
45
Seien Sie vorsichtig, .toFixed()da es eine Zeichenfolge zurückgibt, wenn Sie möglicherweise eine Zahl möchten.
Cobby
1
Cool, offensichtlich werden mit parseFloatDezimalstellen die verbleibenden Dezimalstellen entfernt, .toFixed()wenn es sich um eine ganze Zahl (Nullen) handelt. Wenn Sie rechnen möchten, folgen Sie im Allgemeinen Ihrem ersten Beispiel. Wenn Sie eine Nummer in Ihrer Benutzeroberfläche anzeigen möchten, verwenden Sie .toFixed().
Cobby
Hmmm ... das macht Sinn, jede Art, wie Sie in Zahlen konvertieren, muss immer die fehlerhaften Nullen entfernen, weshalb es eine Zeichenfolge bleiben muss. Ich denke, es sollte immer der letzte Schritt vor der Anzeige sein und nicht in Berechnungen verwendet werden.
Billy Moon
2
Seien Sie vorsichtig, .toFixed()da dies für verschiedene Browser unterschiedliche Rundungsergebnisse liefern kann. Lesen Sie diesen Beitrag für Details zum Thema!
Wilt
1
Kann ich eine Null hinzufügen, wenn kein DP vorhanden ist?
Nick
102
var number = 123.456;

console.log(number.toFixed(1)); // should round to 123.5
Pablo Fernandez
quelle
4
Manchmal toFixed()gibt es Pannen - ich habe es in einem Chrome-Browser gesehen, in dem ich anrufe toFixed(), dann in eine Zeichenfolge konvertiere, und es zeigt etwas wie 10.00000000068- seltsam. Kann dies jedoch nicht zuverlässig reproduzieren.
Hamish Grubijan
Ja, ich habe mit toFixed () sogar mit nur wenigen Dezimalstellen Störungen festgestellt. Wenn ich mich richtig erinnere, wurde Bruch 4 auf die nächsthöhere Zahl anstatt auf die niedrigere gerundet.
Dalibor
1
wie von @cobby oben erwähnt: Seien Sie vorsichtig mit, .toFixed()da es ein zurückgibt, Stringwenn Sie vielleicht einNumber
Ricardo
28

Wenn Sie verwenden, erhalten Math.round(5.01)Sie 5statt 5.0.

Wenn Sie verwenden toFixedSie laufen in Rundungsprobleme .

Wenn Sie das Beste aus beiden Welten wollen, kombinieren Sie beide:

(Math.round(5.01 * 10) / 10).toFixed(1)

Möglicherweise möchten Sie eine Funktion dafür erstellen:

function roundedToFixed(_float, _digits){
  var rounded = Math.pow(10, _digits);
  return (Math.round(_float * rounded) / rounded).toFixed(_digits);
}
Jasper de Vries
quelle
Warum die Unterstriche für die Parameter dh (_float, _digits)? Fühlen Sie sich frei, einfach einen Link zu posten, wo ich die Antwort für mich selbst finden kann. Danke
Shark Lasers
23

lodashhat eine roundMethode:

_.round(4.006);
// => 4

_.round(4.006, 2);
// => 4.01

_.round(4060, -2);
// => 4100

Docs .

Quelle .

Kevin Leary
quelle
11

Ich stimme dafür toFixed(), aber für die Aufzeichnung ist hier eine andere Möglichkeit, die Bitverschiebung verwendet, um die Zahl in ein Int umzuwandeln. Es wird also immer gegen Null gerundet (für positive Zahlen nach unten, für negative nach oben).

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

Aber hey, da es keine Funktionsaufrufe gibt, ist es schnell böse. :) :)

Und hier ist eine, die String-Matching verwendet:

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

Ich empfehle nicht, die String-Variante zu verwenden, nur sayin.

Jimbo
quelle
7

Versuchen Sie es damit:

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 ausführt:

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

BEARBEITEN : siehe hier So runden Sie mit ROUND HALF UP. Rundungsmodus, den die meisten von uns in der Grundschule gelernt haben

atiruz
quelle
Nein: RoundAndFix (1.005, 2).
Noyo
4

x = Zahl, n = Dezimalstellen:

function round(x, n) {
    return Math.round(x * Math.pow(10, n)) / Math.pow(10, n)
}
Super
quelle
Nein: rund (1.005, 2).
Noyo
4

Warum nicht einfach

let myNumber = 213.27321;
+myNumber.toFixed(1); // => 213.3
  1. toFixed : Gibt eine Zeichenfolge zurück, die die angegebene Zahl in Festkommanotation darstellt.
  2. Unäres Plus (+) : Der unäre Plus-Operator steht vor seinem Operanden und wird zu seinem Operanden ausgewertet, versucht jedoch, ihn in eine Zahl umzuwandeln, sofern dies noch nicht geschehen ist.
Gulaschsuppe
quelle
3
var num = 34.7654;

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

console.log(num); // Logs: 34.8
Joseph Silber
quelle
3

So vervollständigen Sie die beste Antwort:

var round = function ( number, precision )
{
    precision = precision || 0;
    return parseFloat( parseFloat( number ).toFixed( precision ) );
}

Die Eingabeparameternummer kann "nicht" immer eine Zahl sein, in diesem Fall existiert .toFixed nicht.

Klodom
quelle
3

ES 6-Version der akzeptierten Antwort:

function round(value, precision) {
    const multiplier = 10 ** (precision || 0);
    return Math.round(value * multiplier) / multiplier;
}
Koustav Ray
quelle
3

Verwenden der toPrecision-Methode:

var a = 1.2345
a.toPrecision(2)

// result "1.2"
EZ
quelle
Mit Abstand die beste Antwort, die ich versucht habe. Vielen Dank.
Ste
Aber du musst vorsichtig sein, weil es so 12.345.toPrecision( 2 )ist "12".
Joshua Pinter
2

Wenn Ihre Methode nicht funktioniert, geben Sie bitte Ihren Code ein.

Sie können die Abrundungsaufgabe jedoch wie folgt ausführen:

var value = Math.round(234.567*100)/100

Wird Ihnen 234,56 geben

Ähnlich

 var value = Math.round(234.567*10)/10

Wird 234,5 geben

Auf diese Weise können Sie eine Variable anstelle der oben verwendeten Konstante verwenden.

jagbandhuster
quelle
1

Kleiner Winkelfilter, wenn jemand es will:

angular.module('filters').filter('decimalPlace', function() {
    return function(num, precision) {
        var multiplier = Math.pow(10, precision || 0);
        return Math.round(num * multiplier) / multiplier;
    };
});

Verwenden Sie, wenn über:

{{model.value| decimalPlace}}
{{model.value| decimalPlace:1}}
{{model.value| decimalPlace:2}}

:) :)

Sidonaldson
quelle
1

Im Allgemeinen erfolgt die Rundung durch Skalierung: round(num / p) * p

Bei Verwendung der Exponentialschreibweise wird die Rundung von + ve Zahlen korrekt behandelt. Bei dieser Methode werden Kantenfälle jedoch nicht korrekt gerundet.

function round(num, precision = 2) {
	var scaled = Math.round(num + "e" + precision);
	return Number(scaled + "e" + -precision);
}

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

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

Hier ist auch eine Funktion, die ich geschrieben habe, um arithmetische Rundungen durchzuführen. Sie können sie selbst testen.

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

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

Amr Ali
quelle
0

Dies scheint bei allem, was ich darauf werfe, zuverlässig zu funktionieren:

function round(val, multiplesOf) {
  var s = 1 / multiplesOf;
  var res = Math.ceil(val*s)/s;
  res = res < val ? res + multiplesOf: res;
  var afterZero = multiplesOf.toString().split(".")[1];
  return parseFloat(res.toFixed(afterZero ? afterZero.length : 0));
}

Es wird abgerundet, sodass Sie es möglicherweise je nach Anwendungsfall ändern müssen. Das sollte funktionieren:

console.log(round(10.01, 1)); //outputs 11
console.log(round(10.01, 0.1)); //outputs 10.1
Ege Özcan
quelle
0

Wenn Ihnen die richtige Aufrundung wichtig ist, dann:

function roundNumericStrings(str , numOfDecPlacesRequired){ 
     var roundFactor = Math.pow(10, numOfDecPlacesRequired);  
     return (Math.round(parseFloat(str)*roundFactor)/roundFactor).toString();  }

Wenn Sie dies nicht tun, haben Sie bereits eine Antwort von früheren Beiträgen

str.slice(0, -1)
jsNovice
quelle
0

Math.round( num * 10) / 10 funktioniert nicht

Zum Beispiel 1455581777.8-145558160.4gibt Ihnen 1310023617.3999999.

Also nur benutzen num.toFixed(1)

PW
quelle
0

Ich habe eine erstellt, die den Zahlentyp zurückgibt und auch nur Dezimalstellen setzt, wenn dies erforderlich ist (keine 0-Auffüllung).

Beispiele:

roundWithMaxPrecision(11.234, 2); //11.23
roundWithMaxPrecision(11.234, 1); //11.2
roundWithMaxPrecision(11.234, 4); //11.23
roundWithMaxPrecision(11.234, -1); //10

roundWithMaxPrecision(4.2, 2); //4.2
roundWithMaxPrecision(4.88, 1); //4.9

Der Code:

function roundWithMaxPrecision (n, precision) {
    return Math.round(n * Math.pow(10, precision)) / Math.pow(10, precision);
}
Alberto
quelle
0

Ich habe einen Weg gefunden, um die Präzisionsprobleme zu vermeiden:

function badRound (num, precision) {
    const x = 10 ** precision;
    return Math.round(num * x) / x
}
// badRound(1.005, 2) --> 1

function round (num, precision) {
    const x = 10 ** (precision + 1);
    const y = 10 ** precision;
    return Math.round(Math.round(num * x) / 10) / y
}
// round(1.005, 2) --> 1.01
Lucas Montenegro
quelle
0
Math.round( mul/count * 10 ) / 10

Math.round(Math.sqrt(sqD/y) * 10 ) / 10

Vielen Dank

Roy Neo
quelle