Javascript: yuvarlanmış bir sayıyı N ondalık basamağa biçimlendirme

JavaScript'te, bir sayıyı N ondalık basamağa yuvarlamanın tipik yolu şuna benzer:

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

Ancak , ben her zaman N ondalık basamağa yuvarlamak isterken, bu yaklaşım en fazla N ondalık basamağa yuvarlayacaktır. Örneğin "2.0", "2" ye yuvarlanır.

Herhangi bir fikir?

Bu bir yuvarlama sorunu değil, bu bir görüntü sorunu. Bir sayı, önemli basamaklar hakkında bilgi içermez; 2 değeri 2.0000000000000 ile aynıdır. Yuvarlanan değeri bir dizeye dönüştürdüğünüzde, belirli sayıda basamak görüntülemesini sağlarsınız.

Sayıdan sonra sıfır ekleyebilirsiniz, örneğin:

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

(Bunun, istemcinin bölgesel ayarlarının ondalık ayırıcı olarak nokta kullandığını varsaydığını, kodun diğer ayarlar için çalışması için biraz daha çalışma gerektirdiğini unutmayın.)

Bence burada verilenlerin hepsine daha basit bir yaklaşım var ve bu yöntem Number.toFixed()zaten JavaScript'te uygulanıyor.

basitçe yazın:

var myNumber = 2;

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

vb...

Bir yol buldum. Bu, Christoph'un düzeltmeli kodu:

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

"+ 1" i neden eklediğimi merak ediyorsanız, burada bir dizi kurucusu kullanarak bir karakteri tekrar etmenin ayrıntılarını okuyun .

Bir şeyler yapmanın her zaman daha iyi bir yolu vardır.

var number = 51.93999999999761;

Dört basamaklı kesinlik elde etmek istiyorum: 51,94

sadece yap:

number.toPrecision(4);

sonuç şöyle olacaktır: 51.94

PHP Benzeri Yuvarlama Yöntemi

Aşağıdaki kod, kendi Math.round sürümünüzü hassas bir parametre alan kendi ad alanınıza eklemek için kullanılabilir. Yukarıdaki örnekteki Ondalık yuvarlamadan farklı olarak, bu, dizelere ve dizelerden dönüştürme yapmaz ve kesinlik parametresi PHP ve Excel ile aynı şekilde çalışır; burada pozitif 1, 1 ondalık basamağa yuvarlanır ve -1, onlara yuvarlanır.

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

dan ) (Math.Round Mozilla Geliştirici referans

Umarım çalışan kod (çok fazla test yapmadı):

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

Bence aşağıdaki işlev yardımcı olabilir

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

kullanım: roundOff(600.23458,2);dönecek600.23

Bu, N basamağa yuvarlamak için çalışır (yalnızca N basamağa kesmek istiyorsanız Math.round çağrısını kaldırın ve Math.trunc birini kullanın):

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

Geçmişte veri işleme E-Slate bileşenlerini yazarken Java'da böyle bir mantığa başvurmak zorunda kaldım . Bu, 0'a defalarca 0.1 eklemenin beklenmedik bir şekilde uzun bir ondalık kısımla sonuçlanacağını öğrendiğimden beri (bu, kayan nokta aritmetiklerinden kaynaklanmaktadır).

Her zaman 2 ondalık basamağı gösteren Biçim numarası'ndaki bir kullanıcı yorumu bu tekniği ölçeklendirmeyi çağırır.

Bazıları beklendiği gibi yuvarlanmayan durumlar olduğunu ve bunun yerine http://www.jacklmoore.com/notes/rounding-in-javascript/ adresinde bunun önerildiğinden bahsediyor :

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

Yuvarlamayı gerçekten umursamıyorsanız, bir Sabit (x) ekleyin ve ardından gerekirse sondaki 0ları ve noktayı kaldırın. Hızlı bir çözüm değil.

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