Jak zaokrąglić do 1 miejsca po przecinku w JavaScript?

Odpowiedzi:

729

Math.round(num * 10) / 10 działa, oto przykład ...

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

jeśli chcesz, aby zawierało jedno miejsce po przecinku, nawet jeśli byłoby to 0, dodaj ...

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!

EDYCJA: Dodaj rundę z funkcją precyzji ...

Dla przykładu, korzystając z tej zasady, jest przydatna mała okrągła funkcja, która wymaga precyzji ...

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

... stosowanie ...

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

... domyślnie zaokrągla się do najbliższej liczby całkowitej (dokładność 0) ...

round(12345.6789) // 12346

... i może być wykorzystany do zaokrąglenia do najbliższej 10 lub 100 itd ...

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

... i prawidłowe postępowanie z liczbami ujemnymi ...

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

... i można łączyć z toFixed, aby konsekwentnie formatować jako ciąg ...

round(456.7, 2).toFixed(2) // "456.70"
Billy Moon
źródło
45
Zachowaj ostrożność, .toFixed()ponieważ zwraca ciąg znaków, gdy chcesz numer.
Cobby
1
Fajne, oczywiście użycie parseFloatspowoduje usunięcie miejsc po przecinku, .toFixed()jeśli jest to liczba całkowita (zera). Ogólnie rzecz biorąc, jeśli chcesz wykonać matematykę, najlepiej pójść za pierwszym przykładem. Jeśli chcesz wyświetlić liczbę w interfejsie użytkownika, użyj .toFixed().
Cobby
Hmmm ... to ma sens, każdy sposób konwersji na liczbę musi zawsze usuwać błędne zera, dlatego musi pozostać ciągiem. Wydaje mi się, że zawsze powinien to być ostatni krok przed wyświetleniem i nie powinien być wykorzystywany w obliczeniach.
Billy Moon,
2
Zachowaj ostrożność, .toFixed()ponieważ może to zwrócić różne wyniki zaokrąglania dla różnych przeglądarek. Przeczytaj ten post, aby uzyskać szczegółowe informacje na ten temat!
Wilt
1
Czy mogę dodać zero, jeśli nie ma DP?
Nick
101
var number = 123.456;

console.log(number.toFixed(1)); // should round to 123.5
Pablo Fernandez
źródło
4
Czasami toFixed()ma usterki - widziałem to w przeglądarce Chrome, do której dzwonię toFixed(), a następnie przekonwertowałem na ciąg znaków i pokazuje coś takiego 10.00000000068- dziwne. Nie można tego jednak wiarygodnie odtworzyć.
Hamish Grubijan
Tak, zaksięgowałem usterki za pomocą toFixed () nawet z kilkoma miejscami po przecinku. Zaokrągliłam ułamek 4 do następnej wyższej liczby zamiast niższej, jeśli dobrze pamiętam.
Dalibor
1
jak wspomniano powyżej przez @cobby: zachowaj ostrożność, .toFixed()ponieważ zwraca, Stringgdy może chceszNumber
Ricardo
28

Jeśli użyjesz Math.round(5.01), otrzymasz 5zamiast 5.0.

Jeśli używasz, toFixedmasz problemy z zaokrąglaniem .

Jeśli chcesz to, co najlepsze z obu światów, połącz dwa:

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

Możesz chcieć utworzyć dla tego funkcję:

function roundedToFixed(_float, _digits){
  var rounded = Math.pow(10, _digits);
  return (Math.round(_float * rounded) / rounded).toFixed(_digits);
}
Jasper de Vries
źródło
Dlaczego podkreślenia dla parametrów tj. (_Float, _digits)? Po prostu opublikuj link, w którym znajdę odpowiedź dla siebie. Dzięki
Shark Lasers
23

lodashma roundmetodę:

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

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

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

Docs .

Źródło .

Kevin Leary
źródło
11

Głosuję za toFixed(), ale, dla przypomnienia, oto inny sposób, który polega na przesunięciu bitowym w celu przekazania liczby na liczbę całkowitą. Tak więc zawsze zaokrągla się do zera (w dół dla liczb dodatnich, w górę dla negatywów).

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

Ale hej, ponieważ nie ma żadnych wywołań funkcji, jest to bardzo złe. :)

A oto taki, który używa dopasowywania ciągów:

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

Nie polecam używania wariantu łańcucha, po prostu powiedz.

jimbo
źródło
7

Spróbuj tego:

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

mniej skomplikowane i łatwiejsze do wdrożenia ...

dzięki temu możesz stworzyć funkcję do wykonania:

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

EDYCJA : zobacz to Jak zaokrąglić za pomocą OKRĄGŁEJ PÓŁKI. Tryb zaokrąglania, którego większość z nas uczyła się w szkole podstawowej

atiruz
źródło
Nie: RoundAndFix (1.005, 2).
Noyo,
4

x = liczba, n = miejsca po przecinku:

function round(x, n) {
    return Math.round(x * Math.pow(10, n)) / Math.pow(10, n)
}
Wspaniały
źródło
Nie: okrągłe (1,005, 2).
Noyo,
4

Dlaczego nie tylko

let myNumber = 213.27321;
+myNumber.toFixed(1); // => 213.3
  1. toFixed : zwraca ciąg reprezentujący podaną liczbę za pomocą notacji o stałym punkcie.
  2. Unary plus (+) : Operator unary plus poprzedza swój operand i ocenia jego operand, ale próbuje przekonwertować go na liczbę, jeśli jeszcze nie jest.
zupa gulaszowa
źródło
3
var num = 34.7654;

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

console.log(num); // Logs: 34.8
Joseph Silber
źródło
3

Aby wypełnić najlepszą odpowiedź:

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

Numer parametru wejściowego może „nie” zawsze być liczbą, w tym przypadku .toFixed nie istnieje.

klodoma
źródło
3

Zaakceptowana wersja ES 6:

function round(value, precision) {
    const multiplier = 10 ** (precision || 0);
    return Math.round(value * multiplier) / multiplier;
}
Koustav Ray
źródło
3

Za pomocą metody toPrecision:

var a = 1.2345
a.toPrecision(2)

// result "1.2"
EZ
źródło
Zdecydowanie najlepsza odpowiedź, jaką próbowałem. Dzięki.
Ste
Ale musisz być ostrożny, ponieważ 12.345.toPrecision( 2 )jest "12".
Joshua Pinter
2

Jeśli twoja metoda nie działa, plz opublikuj swój kod.

Można jednak wykonać zadanie zaokrąglania jako:

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

Otrzymasz 234,56

podobnie

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

Daje 234,5

W ten sposób można użyć zmiennej zamiast stałej, tak jak użyto powyżej.

jagbandhuster
źródło
1

Mały filtr kątowy, jeśli ktoś tego chce:

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

użyj, jeśli:

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

:)

Sidonaldson
źródło
1

Ogólnie zaokrąglanie odbywa się poprzez skalowanie: round(num / p) * p

Prawidłowe użycie uchwytów notacji wykładniczej zaokrąglanie liczb + ve. Jednak ta metoda nie pozwala poprawnie zaokrąglić skrzynek krawędzi.

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

Tutaj jest też jedna funkcja, którą napisałem, aby zaokrąglać arytmetykę, którą możesz sam przetestować.

/**
 * 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
źródło
0

Wydaje się, że działa to niezawodnie we wszystkim, co na to rzucam:

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

Zaokrągla się w górę, więc może być konieczne zmodyfikowanie go odpowiednio do przypadku użycia. To powinno działać:

console.log(round(10.01, 1)); //outputs 11
console.log(round(10.01, 0.1)); //outputs 10.1
Ege Özcan
źródło
0

Jeśli zależy Ci na prawidłowym zaokrągleniu w górę:

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

Jeśli nie, to masz już odpowiedź z poprzednich postów

str.slice(0, -1)
jsNovice
źródło
0

Math.round( num * 10) / 10 nie działa

Na przykład 1455581777.8-145558160.4daje 1310023617.3999999.

Więc tylko używaj num.toFixed(1)

PW
źródło
0

Zrobiłem taki, który zwraca typ liczby, a także umieszcza ułamki dziesiętne tylko wtedy, gdy są potrzebne (bez marginesu 0).

Przykłady:

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

Kod:

function roundWithMaxPrecision (n, precision) {
    return Math.round(n * Math.pow(10, precision)) / Math.pow(10, precision);
}
Alberto
źródło
0

Znalazłem sposób na uniknięcie problemów z precyzją:

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 Czarnogóra
źródło
0
Math.round( mul/count * 10 ) / 10

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

Dzięki

Roy Neo
źródło