JavaScript: formatowanie zaokrąglonej liczby do N miejsc po przecinku

w JavaScript typowym sposobem zaokrągleń liczby do N miejsc dziesiętnych jest:

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

Jednak to podejście zaokrągli maksymalnie do N miejsc dziesiętnych, podczas gdy ja chcę zawsze zaokrąglić do N miejsc dziesiętnych. Na przykład „2,0” zostanie zaokrąglone do „2”.

Jakieś pomysły?

To nie jest problem z zaokrągleniem, to jest problem z wyświetlaniem. Liczba nie zawiera informacji o cyfrach znaczących; wartość 2 jest taka sama jak 2,0000000000000. To wtedy, gdy zamienisz zaokrągloną wartość na ciąg, sprawisz, że wyświetli określoną liczbę cyfr.

Możesz po prostu dodać zera po liczbie, na przykład:

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

(Należy zauważyć, że przy założeniu, że ustawienia regionalne klienta używają kropki jako separatora dziesiętnego, kod wymaga trochę więcej pracy, aby działał dla innych ustawień).

Myślę, że istnieje prostsze podejście do wszystkich podanych tutaj i jest to metoda Number.toFixed()już zaimplementowana w JavaScript.

po prostu napisz:

var myNumber = 2;

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

itp...

Znalazłem drogę. Oto kod Christopha z poprawką:

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

Przeczytaj szczegóły dotyczące powtarzania znaku przy użyciu konstruktora tablicy , jeśli jesteś ciekawy, dlaczego dodałem „+ 1”.

Zawsze jest lepszy sposób na robienie rzeczy.

var number = 51.93999999999761;

Chciałbym uzyskać dokładność czterech cyfr: 51,94

po prostu zrób:

number.toPrecision(4);

wynikiem będzie: 51,94

Metoda zaokrąglania podobna do PHP

Poniższy kod może służyć do dodawania własnej wersji Math.round do własnej przestrzeni nazw, która przyjmuje parametr precyzji. W przeciwieństwie do zaokrąglania dziesiętnego w powyższym przykładzie, nie powoduje to konwersji do iz ciągów, a parametr precyzji działa tak samo jak PHP i Excel, gdzie dodatnia 1 zaokrągliłaby do 1 miejsca dziesiętnego, a -1 do dziesiątek.

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

z dokumentacji Mozilla Developer dla Math.round ()

Mam nadzieję, że działający kod (nie wykonał zbyt wielu testów):

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

Myślę, że poniżej funkcja może pomóc

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

użycie: roundOff(600.23458,2);powróci600.23

Działa to w przypadku zaokrąglania do N cyfr (jeśli chcesz tylko skrócić do N cyfr, usuń wywołanie Math.round i użyj Math.trunc):

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

Musiałem uciekać się do takiej logiki w Javie w przeszłości, kiedy tworzyłem komponenty E-Slate do manipulacji danymi . Dzieje się tak, ponieważ odkryłem, że dodając wiele razy 0,1 do 0, otrzymujesz nieoczekiwanie długą część dziesiętną (jest to spowodowane arytmetyką zmiennoprzecinkową).

Komentarz użytkownika pod numerem Format, aby zawsze pokazywać 2 miejsca po przecinku, wywołuje tę technikę skalowania.

Niektórzy wspominają, że istnieją przypadki, które nie zaokrągla się zgodnie z oczekiwaniami, a na http://www.jacklmoore.com/notes/rounding-in-javascript/ sugeruje się zamiast tego:

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

Jeśli naprawdę nie zależy ci na zaokrąglaniu, po prostu dodaj toFixed (x), a następnie usuń końcowe zera i kropkę, jeśli to konieczne. Nie jest to szybkie rozwiązanie.

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