Wie rundet man in Javascript auf 1 Dezimalstelle?

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

Ich habe die * 10, round, / 10 ausprobiert, aber am Ende des int bleiben zwei Dezimalstellen.

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"

var number = 123.456;

console.log(number.toFixed(1)); // should round to 123.5

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

lodashhat eine roundMethode:

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

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

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

Docs .

Quelle .

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.

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

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

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

x = Zahl, n = Dezimalstellen:

function round(x, n) {
    return Math.round(x * Math.pow(10, n)) / Math.pow(10, n)
}

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.

var num = 34.7654;

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

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

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.

ES 6-Version der akzeptierten Antwort:

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

Verwenden der toPrecision-Methode:

var a = 1.2345
a.toPrecision(2)

// result "1.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.

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

:) :)

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

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

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)

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

Zum Beispiel 1455581777.8-145558160.4gibt Ihnen 1310023617.3999999.

Also nur benutzen num.toFixed(1)

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

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

Math.round( mul/count * 10 ) / 10

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

Vielen Dank