Sayıyı her zaman 2 ondalık basamak gösterecek şekilde biçimlendir

Numaralarımı her zaman 2 ondalık basamak gösterecek şekilde biçimlendirmek istiyorum, uygun olduğunda yuvarlama.

Örnekler:

number     display
------     -------
1          1.00
1.341      1.34
1.345      1.35

Bunu kullanıyorum:

parseFloat(num).toFixed(2);

Ancak , yerine 1olarak görüntüleniyor .11.00

(Math.round(num * 100) / 100).toFixed(2);

Canlı Demo

var num1 = "1";
document.getElementById('num1').innerHTML = (Math.round(num1 * 100) / 100).toFixed(2);

var num2 = "1.341";
document.getElementById('num2').innerHTML = (Math.round(num2 * 100) / 100).toFixed(2);

var num3 = "1.345";
document.getElementById('num3').innerHTML = (Math.round(num3 * 100) / 100).toFixed(2);

span {
    border: 1px solid #000;
    margin: 5px;
    padding: 5px;
}

<span id="num1"></span>
<span id="num2"></span>
<span id="num3"></span>

2 ondalık basamağa yuvarlanacağına dikkat edin , böylece giriş 1.346geri dönecektir 1.35.

Number(1).toFixed(2);         // 1.00
Number(1.341).toFixed(2);     // 1.34
Number(1.345).toFixed(2);     // 1.34 NOTE: See andy's comment below.
Number(1.3450001).toFixed(2); // 1.35

document.getElementById('line1').innerHTML = Number(1).toFixed(2);
document.getElementById('line2').innerHTML = Number(1.341).toFixed(2);
document.getElementById('line3').innerHTML = Number(1.345).toFixed(2);
document.getElementById('line4').innerHTML = Number(1.3450001).toFixed(2);

<span id="line1"></span>
<br/>
<span id="line2"></span>
<br/>
<span id="line3"></span>
<br/>
<span id="line4"></span>

Eğer bu cevap başarısız olur value = 1.005.

Daha iyi bir çözüm olarak, yuvarlama problemi üstel gösterimde temsil edilen sayılar kullanılarak önlenebilir:

Number(Math.round(1.005+'e2')+'e-2'); // 1.01

@Kon tarafından önerildiği gibi daha temiz kod ve orijinal yazar:

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces)

toFixed()Ondalık noktayı korumak için sonuna ekleyebilirsiniz , örneğin: 1.00ancak dize olarak döneceğini unutmayın.

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces).toFixed(decimalPlaces)

Kredi bilgileri: JavaScript'te Ondalık Sayıları Yuvarlama

var num = new Number(14.12);
console.log(num.toPrecision(2));//outputs 14
console.log(num.toPrecision(3));//outputs 14.1
console.log(num.toPrecision(4));//outputs 14.12
console.log(num.toPrecision(5));//outputs 14.120

En doğru yuvarlama için bu işlevi oluşturun:

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

ve 2 ondalık basamağa yuvarlamak için kullanın:

console.log("seeked to " + round(1.005, 2));
> 1.01

Sayesinde Razu , bu yazıda ve MDN en Math.round referansı .

Modern tarayıcılar için toLocaleStringşunları kullanın :

var num = 1.345;
num.toLocaleString(undefined, { maximumFractionDigits: 2, minimumFractionDigits: 2 });

Ondalık ayırıcıyı kontrol etmek için ilk parametre olarak bir yerel ayar etiketi belirtin . Nokta için, örneğin İngilizce ABD yerel ayarını kullanın:

num.toLocaleString("en-US", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

hangi verir:

1.35

Avrupa'daki çoğu ülke ondalık ayırıcı olarak virgül kullanır, bu nedenle örneğin İsveç / İsveç yerel ayarını kullanırsanız:

num.toLocaleString("sv-SE", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

verecek:

1,35

En basit cevap:

var num = 1.2353453;
num.toFixed(2); // 1.24

Örnek: http://jsfiddle.net/E2XU7/

N yere yuvarlamak için çok daha genel bir çözüm

function roundN(num,n){
  return parseFloat(Math.round(num * Math.pow(10, n)) /Math.pow(10,n)).toFixed(n);
}


console.log(roundN(1,2))
console.log(roundN(1.34,2))
console.log(roundN(1.35,2))
console.log(roundN(1.344,2))
console.log(roundN(1.345,2))
console.log(roundN(1.344,3))
console.log(roundN(1.345,3))
console.log(roundN(1.3444,3))
console.log(roundN(1.3455,3))

Output

1.00
1.34
1.35
1.34
1.35
1.344
1.345
1.344
1.346

var number = 123456.789;


console.log(new Intl.NumberFormat('en-IN', { maximumFractionDigits: 2 }).format(number));

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat

Zaten jQuery kullanıyorsanız, jQuery Sayı Biçimi eklentisini kullanarak bakabilirsiniz .

Eklenti, biçimlendirilmiş sayıları dize olarak döndürebilir, ondalık ve binlik ayırıcı ayarlayabilirsiniz ve gösterilecek ondalık sayıları seçebilirsiniz.

$.number( 123, 2 ); // Returns '123.00'

GitHub'dan jQuery Sayı Formatını da alabilirsiniz .

Demek istediğin bu mu?

function showAsFloat(num, n){
      return !isNaN(+num) ? (+num).toFixed(n || 2) : num;
}

document.querySelector('#result').textContent = 
    [
     'command                      | result',
     '-----------------------------------------------',
     'showAsFloat(1);              | ' + showAsFloat(1),
     'showAsFloat(1.314);          | ' + showAsFloat(1.314),
     'showAsFloat(\'notanumber\')    | ' + showAsFloat('notanumber'),
     'showAsFloat(\'23.44567\', 3)   | ' + showAsFloat('23.44567', 3),
     'showAsFloat(2456198, 5)      | ' + showAsFloat('2456198', 5),
     'showAsFloat(0);              | ' + showAsFloat(0)
    ].join('\n');

<pre id="result"></pre>

Bir sayıyı yalnızca iki ondalık basamak tutarak dizeye dönüştürün:

var num = 5.56789;
var n = num.toFixed(2);

N'nin sonucu şöyle olacaktır:

5.57

Zemin mi arıyorsunuz?

var num = 1.42482;
var num2 = 1;
var fnum = Math.floor(num).toFixed(2);
var fnum2 = Math.floor(num2).toFixed(2);
alert(fnum + " and " + fnum2); //both values will be 1.00

function currencyFormat (num) {
    return "$" + num.toFixed(2).replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1,")
}

console.info(currencyFormat(2665));   // $2,665.00
console.info(currencyFormat(102665)); // $102,665.00

Ayrıca, herhangi bir sayıda ondalık basamağa biçimlendirebilen genel bir işlev de vardır:

function numberFormat(val, decimalPlaces) {

    var multiplier = Math.pow(10, decimalPlaces);
    return (Math.round(val * multiplier) / multiplier).toFixed(decimalPlaces);
}

Özel biçimlendirme gerektiğinde, kendi rutininizi yazmalı veya ihtiyacınız olanı yapan bir kütüphane işlevi kullanmalısınız. Temel ECMAScript işlevi, biçimlendirilmiş sayıları görüntülemek için genellikle yetersizdir.

Yuvarlama ve biçimlendirme hakkında ayrıntılı açıklama burada: http://www.merlyn.demon.co.uk/js-round.htm#RiJ

Genel bir kural olarak, yuvarlama ve biçimlendirme yalnızca çıktıdan önceki son adım olarak gerçekleştirilmelidir. Bunu daha önce yapmak beklenmedik derecede büyük hatalar verebilir ve biçimlendirmeyi yok edebilir.

Sadece bu en uzun iplik biri içine koşmak, aşağıda benim çözüm:

parseFloat(Math.round((parseFloat(num * 100)).toFixed(2)) / 100 ).toFixed(2)

Birinin bir delik açıp açamadığını bana bildirin

Bize resmin tamamını vermiyorsunuz.

javascript:alert(parseFloat(1).toFixed(2))konum çubuğuna int0 yapıştırdığımda tarayıcılarımda 1.00 gösteriyor. Ancak daha sonra ona bir şey yaparsanız, geri döner.

var num = 2
document.getElementById('spanId').innerHTML=(parseFloat(num).toFixed(2)-1)


shows 1 and not 1.00

var quantity = 12;

var import1 = 12.55;

var total = quantity * import1;

var answer = parseFloat(total).toFixed(2);

document.write(answer);

Ben toFixed () çağrı yapmadan önce parseFloat () ve Number () dönüşümleri arasında karar vermek zorunda kaldı. Aşağıda, yakalama sonrası kullanıcı girişini biçimlendiren bir sayı örneği verilmiştir.

HTML:

<input type="number" class="dec-number" min="0" step="0.01" />

Olay işleyicisi:

$('.dec-number').on('change', function () {
     const value = $(this).val();
     $(this).val(value.toFixed(2));
});

Yukarıdaki kod, TypeError istisnasına neden olacaktır. Html giriş türü "sayı" olmasına rağmen, kullanıcı girişinin aslında bir "dize" veri türü olduğunu unutmayın. Ancak, toFixed () işlevi yalnızca Sayı olan bir nesnede çağrılabilir.

Son kodum aşağıdaki gibi görünecektir:

$('.dec-number').on('change', function () {
     const value = Number($(this).val());
     $(this).val(value.toFixed(2));
});

Ben parseFloat () vs Number () ile döküm tercih sebebi ne boş bir giriş dizesi, ne de NaN değeri için ekstra bir doğrulama yapmak zorunda değilsiniz. Number () işlevi otomatik olarak boş bir dizeyi işleyecek ve sıfıra çevirecektir.

Seviyorum:

var num = 12.749;
parseFloat((Math.round(num * 100) / 100).toFixed(2)); // 123.75

Sayıyı 2 ondalık nokta ile yuvarlayın, ardından parseFloat() Dize veya Sayı olup olmadığını umursamadığınızda Dize değil Sayı döndürmek için ayrıştırdığınızdan emin olun .

Math nesnesini hassas yöntemle genişletme

Object.defineProperty(Math, 'precision',{
   value: function (value,precision,type){
             var v = parseFloat(value),
                 p = Math.max(precision,0)||0,
                 t = type||'round';
              return (Math[t](v*Math.pow(10,p))/Math.pow(10,p)).toFixed(p);
          }
    });

console.log(
    Math.precision(3.1,3), // round 3 digits 
    Math.precision(0.12345,2,'ceil'), // ceil 2 digits
    Math.precision(1.1) // integer part
)

parseInt(number * 100) / 100; benim için çalıştı.

burada yalnızca zemini kullanarak yuvarlamak için başka bir çözüm, yani hesaplanan miktarın orijinal miktardan daha büyük olmayacağından emin olmak (bazen işlemler için gerekli olabilir):

Math.floor(num* 100 )/100;

Bu kodu deneyebilirsiniz:

    function FormatNumber(number, numberOfDigits = 2) {
        try {
            return new Intl.NumberFormat('en-US').format(parseFloat(number).toFixed(2));
        } catch (error) {
            return 0;
        }
    }

    var test1 = FormatNumber('1000000.4444');
    alert(test1); // 1,000,000.44

    var test2 = FormatNumber(100000000000.55555555, 4);
    alert(test2); // 100,000,000,000.56

Aşağıdaki kodu deneyin:

function numberWithCommas(number) { 

   var newval = parseFloat(Math.round(number * 100) / 100).toFixed(2);

   return newval.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}

(num + "").replace(/^([0-9]*)(\.[0-9]{1,2})?.*$/,"$1$2")

Sorunumu şu şekilde çözerim:

parseFloat(parseFloat(floatString).toFixed(2));