15.7784514 değerine sahip olduğumu varsayalım, yuvarlama olmadan 15.77 görüntülemek istiyorum.

var num = parseFloat(15.7784514);
document.write(num.toFixed(1)+"<br />");
document.write(num.toFixed(2)+"<br />");
document.write(num.toFixed(3)+"<br />");
document.write(num.toFixed(10));

Sonuçları -

15.8
15.78
15.778
15.7784514000 

15.77'yi nasıl görüntülerim?

Sayıyı bir dizeye dönüştürün, sayıyı ikinci ondalık basamağa kadar eşleştirin:

function calc(theform) {
    var num = theform.original.value, rounded = theform.rounded
    var with2Decimals = num.toString().match(/^-?\d+(?:\.\d{0,2})?/)[0]
    rounded.value = with2Decimals
}

<form onsubmit="return calc(this)">
Original number: <input name="original" type="text" onkeyup="calc(form)" onchange="calc(form)" />
<br />"Rounded" number: <input name="rounded" type="text" placeholder="readonly" readonly>
</form>

toFixedYöntem aksine bazı durumlarda başarısız toStringyüzden çok dikkatli olun.

Güncelleme 5 Kasım 2016

Yeni cevap, her zaman doğru

function toFixed(num, fixed) {
    var re = new RegExp('^-?\\d+(?:\.\\d{0,' + (fixed || -1) + '})?');
    return num.toString().match(re)[0];
}

Gibi javascript nokta matematik yüzen hep sınır durumları olacak, önceki çözüm yeterince iyi değil çoğu zaman doğru olacaktır. Bazıları gibi bu çözümler vardır num.toPrecision, BigDecimal.js ve accounting.js . Yine de, sadece dizeyi ayrıştırmanın en basit ve her zaman doğru olacağına inanıyorum.

Güncellemeyi @Gumbo tarafından kabul edilen cevaptan iyi yazılmış normal ifadeye dayandırdığımızda, bu yeni toFixed işlevi her zaman beklendiği gibi çalışacaktır.

Eski cevap, her zaman doğru değil.

Kendi sabit fonksiyonunuzu yuvarlayın:

function toFixed(num, fixed) {
    fixed = fixed || 0;
    fixed = Math.pow(10, fixed);
    return Math.floor(num * fixed) / fixed;
}

Ben bunun yerine sayılarla gelen matematik sorunları ile uğraşmak zorunda kalmamak için dizeleri ile kalanını el ile kaldırmak için yazmayı seçti:

num = num.toString(); //If it's not already a String
num = num.slice(0, (num.indexOf("."))+3); //With 3 exposing the hundredths place
Number(num); //If you need it back as a Number

Bu size num = 15.7784514 ile "15.77" verecektir;

Ekim 2017

Bir sayıyı n'inci ondalık basamağa kısaltmak (yuvarlamamak) ve herhangi bir n≥0 için tam olarak n ondalık basamağa sahip bir dizgeye dönüştürmek için genel çözüm.

function toFixedTrunc(x, n) {
  const v = (typeof x === 'string' ? x : x.toString()).split('.');
  if (n <= 0) return v[0];
  let f = v[1] || '';
  if (f.length > n) return `${v[0]}.${f.substr(0,n)}`;
  while (f.length < n) f += '0';
  return `${v[0]}.${f}`
}

burada x, bir sayı (dizgeye dönüştürülür) veya bir dize olabilir.

N = 2 için bazı testler (OP tarafından talep edilenler dahil):

0           => 0.00
0.01        => 0.01
0.5839      => 0.58
0.999       => 0.99
1.01        => 1.01
2           => 2.00
2.551       => 2.55
2.99999     => 2.99
4.27        => 4.27
15.7784514  => 15.77
123.5999    => 123.59
0.000000199 => 1.99 *

* Notta belirtildiği gibi, bunun nedeni javascript'in "1.99e-7" için üslü örtüşmeye dönüşmesi ve n'nin diğer bazı değerleri için:

15.001097   => 15.0010 (n=4)
0.000003298 => 0.0000032 (n=7)
0.000003298257899 => 0.000003298257 (n=12)

parseInt Math.floor'dan daha hızlı

function floorFigure(figure, decimals){
    if (!decimals) decimals = 2;
    var d = Math.pow(10,decimals);
    return (parseInt(figure*d)/d).toFixed(decimals);
};

floorFigure(123.5999)    =>   "123.59"
floorFigure(123.5999, 3) =>   "123.599"

num = 19.66752
f = num.toFixed(3).slice(0,-1)
alert(f)

Bu 19,66 döndürecektir

Basit yap bunu

number = parseInt(number * 100)/100;

Bu çözümler işe yarıyor, ama benim için gereksiz yere karmaşık görünüyor. Ben şahsen bir bölme işleminin geri kalanını elde etmek için modül operatörünü kullanmayı ve bunu kaldırmayı seviyorum. Bu num = 15.7784514 olduğunu varsayarsak:

num-=num%.01;

Bu, num = num - (num% .01) demeye eşdeğerdir.

Buradaki cevaplar bana yardımcı olmadı, yuvarlanmaya devam etti veya bana yanlış ondalık veriyordu.

benim çözüm ondalık bir dize dönüştürür, karakter ayıklar ve sonra her şeyi bir sayı olarak döndürür.

function Dec2(num) {
  num = String(num);
  if(num.indexOf('.') !== -1) {
    var numarr = num.split(".");
    if (numarr.length == 1) {
      return Number(num);
    }
    else {
      return Number(numarr[0]+"."+numarr[1].charAt(0)+numarr[1].charAt(1));
    }
  }
  else {
    return Number(num);
  }  
}

Dec2(99); // 99
Dec2(99.9999999); // 99.99
Dec2(99.35154); // 99.35
Dec2(99.8); // 99.8
Dec2(10265.985475); // 10265.98

Pozitif sayılar için sürümüm:

function toFixed_norounding(n,p)
{
    var result = n.toFixed(p);
    return result <= n ? result: (result - Math.pow(0.1,p)).toFixed(p);
}

Hızlı, güzel, açık. (pozitif sayılar için sürüm)

Aşağıdaki kod benim için çok iyi çalışıyor:

num.toString().match(/.\*\\..{0,2}|.\*/)[0];

Aşağıdaki basit yolu kullanarak sabitledim

var num = 15.7784514;
Math.floor(num*100)/100;

Sonuçlar 15.77

Sadece rakamları kısaltın:

function truncDigits(inputNumber, digits) {
  const fact = 10 ** digits;
  return Math.floor(inputNumber * fact) / fact;
}

Başka bir tek satırlık çözüm:

number = Math.trunc(number*100)/100

100 kullandım çünkü ikinci basamağa kısaltmak istiyorsunuz, ancak daha esnek bir çözüm:

number = Math.trunc(number*Math.pow(10, digits))/Math.pow(10, digits)

Burada basamaklar, saklanacak ondalık basamak miktarıdır.

Ayrıntılar ve tarayıcı uyumluluğu için Math.trunc teknik özelliklerine bakın .

Buyrun. Sorunu çözmenin başka bir yolunu gösteren bir cevap:

// For the sake of simplicity, here is a complete function:
function truncate(numToBeTruncated, numOfDecimals) {
    var theNumber = numToBeTruncated.toString();
    var pointIndex = theNumber.indexOf('.');
    return +(theNumber.slice(0, pointIndex > -1 ? ++numOfDecimals + pointIndex : undefined));
}

Son ifadeden önce + işaretinin kullanıldığına dikkat edin. Bu, kesilmiş, dilimlenmiş dizgimizi sayı tipine dönüştürmektir.

Umarım yardımcı olur!

sıfır olmadan kes

function toTrunc(value,n){  
    return Math.floor(value*Math.pow(10,n))/(Math.pow(10,n));
}

veya

function toTrunc(value,n){
    x=(value.toString()+".0").split(".");
    return parseFloat(x[0]+"."+x[1].substr(0,n));
}

Ölçek:

toTrunc(17.4532,2)  //17.45
toTrunc(177.4532,1) //177.4
toTrunc(1.4532,1)   //1.4
toTrunc(.4,2)       //0.4

sıfırlarla kısalt

function toTruncFixed(value,n){
    return toTrunc(value,n).toFixed(n);
}

Ölçek:

toTrunc(17.4532,2)  //17.45
toTrunc(177.4532,1) //177.4
toTrunc(1.4532,1)   //1.4
toTrunc(.4,2)       //0.40

Bu benim için iyi çalıştı. Umarım sorunlarınızı da düzeltir.

function toFixedNumber(number) {
    const spitedValues = String(number.toLocaleString()).split('.');
    let decimalValue = spitedValues.length > 1 ? spitedValues[1] : '';
    decimalValue = decimalValue.concat('00').substr(0,2);

    return '$'+spitedValues[0] + '.' + decimalValue;
}

// 5.56789      ---->  $5.56
// 0.342        ---->  $0.34
// -10.3484534  ---->  $-10.34 
// 600          ---->  $600.00

function convertNumber(){
  var result = toFixedNumber(document.getElementById("valueText").value);
  document.getElementById("resultText").value = result;
}


function toFixedNumber(number) {
        const spitedValues = String(number.toLocaleString()).split('.');
        let decimalValue = spitedValues.length > 1 ? spitedValues[1] : '';
        decimalValue = decimalValue.concat('00').substr(0,2);

        return '$'+spitedValues[0] + '.' + decimalValue;
}

<div>
  <input type="text" id="valueText" placeholder="Input value here..">
  <br>
  <button onclick="convertNumber()" >Convert</button>
  <br><hr>
  <input type="text" id="resultText" placeholder="result" readonly="true">
</div>

Bunu yapmanın kolay bir yolu bir sonraki yöntemdir, ancak amount parametresinin bir dize olarak verildiğinden emin olmak gerekir.

function truncate(amountAsString, decimals = 2){
  var dotIndex = amountAsString.indexOf('.');
  var toTruncate = dotIndex !== -1  && ( amountAsString.length > dotIndex + decimals + 1);
  var approach = Math.pow(10, decimals);
  var amountToTruncate = toTruncate ? amountAsString.slice(0, dotIndex + decimals +1) : amountAsString;  
  return toTruncate
    ?  Math.floor(parseFloat(amountToTruncate) * approach ) / approach
    :  parseFloat(amountAsString);

}

console.log(truncate("7.99999")); //OUTPUT ==> 7.99
console.log(truncate("7.99999", 3)); //OUTPUT ==> 7.999
console.log(truncate("12.799999999999999")); //OUTPUT ==> 7.99

Kullandığım (num-0.05).toFixed(1)ikinci ondalık katlı olsun.

Daktilodaki çözümüm (JS'ye kolayca taşınabilir):

/**
 * Returns the price with correct precision as a string
 *
 * @param   price The price in decimal to be formatted.
 * @param   decimalPlaces The number of decimal places to use
 * @return  string The price in Decimal formatting.
 */
type toDecimal = (price: number, decimalPlaces?: number) => string;
const toDecimalOdds: toDecimal = (
  price: number,
  decimalPlaces: number = 2,
): string => {
  const priceString: string = price.toString();
  const pointIndex: number = priceString.indexOf('.');

  // Return the integer part if decimalPlaces is 0
  if (decimalPlaces === 0) {
    return priceString.substr(0, pointIndex);
  }

  // Return value with 0s appended after decimal if the price is an integer
  if (pointIndex === -1) {
    const padZeroString: string = '0'.repeat(decimalPlaces);

    return `${priceString}.${padZeroString}`;
  }

  // If numbers after decimal are less than decimalPlaces, append with 0s
  const padZeroLen: number = priceString.length - pointIndex - 1;
  if (padZeroLen > 0 && padZeroLen < decimalPlaces) {
    const padZeroString: string = '0'.repeat(padZeroLen);

    return `${priceString}${padZeroString}`;
  }

  return priceString.substr(0, pointIndex + decimalPlaces + 1);
};

Test senaryoları:

  expect(filters.toDecimalOdds(3.14159)).toBe('3.14');
  expect(filters.toDecimalOdds(3.14159, 2)).toBe('3.14');
  expect(filters.toDecimalOdds(3.14159, 0)).toBe('3');
  expect(filters.toDecimalOdds(3.14159, 10)).toBe('3.1415900000');
  expect(filters.toDecimalOdds(8.2)).toBe('8.20');

Herhangi bir gelişme var mı?

Kendi toFixedfonksiyonunuzu yuvarlayın : pozitif değerler için Math.flooriyi çalışır.

function toFixed(num, fixed) {
    fixed = fixed || 0;
    fixed = Math.pow(10, fixed);
    return Math.floor(num * fixed) / fixed;
}

Negatif değerler Math.flooriçin değerler yuvarlanır. Bunun Math.ceilyerine kullanabilirsiniz .

Misal,

Math.ceil(-15.778665 * 10000) / 10000 = -15.7786
Math.floor(-15.778665 * 10000) / 10000 = -15.7787 // wrong.

Gumbo'nun ikinci çözümü, normal ifade ile işe yarıyor, ancak normal ifade nedeniyle yavaş. Gumbo'nun ilk çözümü kayan nokta sayısındaki kesinsizlik nedeniyle bazı durumlarda başarısız olur. Bir gösteri ve bir kıyaslama için JSFiddle'a bakın . İkinci çözüm, mevcut sistemim olan Intel Core i5-2500 CPU'da 3.30 GHz'de arama başına yaklaşık 1636 nanosaniye sürüyor.

Yazdığım çözüm, kayan nokta belirsizliğine dikkat etmek için küçük bir tazminat eklemeyi içerir. Temelde anlık, yani nanosaniye mertebesinde. Arama başına 2 nanosaniye saat ayarladım ancak JavaScript zamanlayıcıları çok hassas veya ayrıntılı değil. İşte JS Fiddle ve kodu.

function toFixedWithoutRounding (value, precision)
{
    var factorError = Math.pow(10, 14);
    var factorTruncate = Math.pow(10, 14 - precision);
    var factorDecimal = Math.pow(10, precision);
    return Math.floor(Math.floor(value * factorError + 1) / factorTruncate) / factorDecimal;
}

var values = [1.1299999999, 1.13, 1.139999999, 1.14, 1.14000000001, 1.13 * 100];

for (var i = 0; i < values.length; i++)
{
    var value = values[i];
    console.log(value + " --> " + toFixedWithoutRounding(value, 2));
}

for (var i = 0; i < values.length; i++)
{
    var value = values[i];
    console.log(value + " --> " + toFixedWithoutRounding(value, 4));
}

console.log("type of result is " + typeof toFixedWithoutRounding(1.13 * 100 / 100, 2));

// Benchmark
var value = 1.13 * 100;
var startTime = new Date();
var numRun = 1000000;
var nanosecondsPerMilliseconds = 1000000;

for (var run = 0; run < numRun; run++)
    toFixedWithoutRounding(value, 2);

var endTime = new Date();
var timeDiffNs = nanosecondsPerMilliseconds * (endTime - startTime);
var timePerCallNs = timeDiffNs / numRun;
console.log("Time per call (nanoseconds): " + timePerCallNs);

David D'nin cevabı üzerine inşa :

function NumberFormat(num,n) {
  var num = (arguments[0] != null) ? arguments[0] : 0;
  var n = (arguments[1] != null) ? arguments[1] : 2;
  if(num > 0){
    num = String(num);
    if(num.indexOf('.') !== -1) {
      var numarr = num.split(".");
      if (numarr.length > 1) {
        if(n > 0){
          var temp = numarr[0] + ".";
          for(var i = 0; i < n; i++){
            if(i < numarr[1].length){
              temp += numarr[1].charAt(i);
            }
          }
          num = Number(temp);
        }
      }
    }
  }
  return Number(num);
}

console.log('NumberFormat(123.85,2)',NumberFormat(123.85,2));
console.log('NumberFormat(123.851,2)',NumberFormat(123.851,2));
console.log('NumberFormat(0.85,2)',NumberFormat(0.85,2));
console.log('NumberFormat(0.851,2)',NumberFormat(0.851,2));
console.log('NumberFormat(0.85156,2)',NumberFormat(0.85156,2));
console.log('NumberFormat(0.85156,4)',NumberFormat(0.85156,4));
console.log('NumberFormat(0.85156,8)',NumberFormat(0.85156,8));
console.log('NumberFormat(".85156",2)',NumberFormat(".85156",2));
console.log('NumberFormat("0.85156",2)',NumberFormat("0.85156",2));
console.log('NumberFormat("1005.85156",2)',NumberFormat("1005.85156",2));
console.log('NumberFormat("0",2)',NumberFormat("0",2));
console.log('NumberFormat("",2)',NumberFormat("",2));
console.log('NumberFormat(85156,8)',NumberFormat(85156,8));
console.log('NumberFormat("85156",2)',NumberFormat("85156",2));
console.log('NumberFormat("85156.",2)',NumberFormat("85156.",2));

// NumberFormat(123.85,2) 123.85
// NumberFormat(123.851,2) 123.85
// NumberFormat(0.85,2) 0.85
// NumberFormat(0.851,2) 0.85
// NumberFormat(0.85156,2) 0.85
// NumberFormat(0.85156,4) 0.8515
// NumberFormat(0.85156,8) 0.85156
// NumberFormat(".85156",2) 0.85
// NumberFormat("0.85156",2) 0.85
// NumberFormat("1005.85156",2) 1005.85
// NumberFormat("0",2) 0
// NumberFormat("",2) 0
// NumberFormat(85156,8) 85156
// NumberFormat("85156",2) 85156
// NumberFormat("85156.",2) 85156

Yuvarlamadan iki kayan nokta elde etmek daha güvenilirdir.

Referans Cevabı

var number = 10.5859;
var fixed2FloatPoints = parseInt(number * 100) / 100;
console.log(fixed2FloatPoints);

Teşekkür ederim !

Zaten düzenli ifade ve aritmetik hesaplama ile bazı uygun cevaplar var, bunu da deneyebilirsiniz

function myFunction() {
    var str = 12.234556; 
    str = str.toString().split('.');
    var res = str[1].slice(0, 2);
    document.getElementById("demo").innerHTML = str[0]+'.'+res;
}

// output: 12.23

İşte dize ile ne yaptı

export function withoutRange(number) {
  const str = String(number);
  const dotPosition = str.indexOf('.');
  if (dotPosition > 0) {
    const length = str.substring().length;
    const end = length > 3 ? 3 : length;
    return str.substring(0, dotPosition + end);
  }
  return str;
}

Tüm bu cevaplar biraz karmaşık görünüyor. Sadece numaranızdan 0.5 çıkarır ve toFixed () kullanırdım.

En etkili çözüm (2 kesir basamağı için) çağırmadan önce 0.005 çıkarmaktır toFixed()

function toFixed2( num ) { return (num-0.005).toFixed(2) }

Negatif sayılar da yuvarlanır (sıfırdan uzağa). OP negatif sayılar hakkında bir şey söylemedi.

Zaten birkaç çalışma örneği olduğunu biliyorum, ancak benim String.toFixed eşdeğerini teklif etmeye değer olduğunu düşünüyorum, bazı yardımcı olabilir.

Bu benim sabit seçeneğim, sayıları yuvarlamayan, sadece kesen veya verilen hassasiyete göre sıfır ekleyen. Ekstra uzun sayı için, hassasiyet uzun olduğunda JS dahili yuvarlama kullanır. İşlev yığın üzerinde bulduğum tüm sorunlu numaralar için çalışır.

function toFixedFixed(value, precision = 0) {
    let stringValue = isNaN(+value) ? '0' : String(+value);

    if (stringValue.indexOf('e') > -1 || stringValue === 'Infinity' || stringValue === '-Infinity') {
        throw new Error('To large number to be processed');
    }

    let [ beforePoint, afterPoint ] = stringValue.indexOf('.') > -1 ? stringValue.split('.') : [ stringValue, ''];

    // Force automatic rounding for some long real numbers that ends with 99X, by converting it to string, cutting off last digit, then adding extra nines and casting it on number again
    // e.g. 2.0199999999999996: +('2.019999999999999' + '9999') will give 2.02
    if (stringValue.length >= 17 && afterPoint.length > 2 && +afterPoint.substr(afterPoint.length - 3) > 995) {
        stringValue = String(+(stringValue.substr(0, afterPoint.length - 1) + '9'.repeat(stringValue.split('.').shift().length + 4)));
        [ beforePoint, afterPoint ] = String(stringValue).indexOf('.') > -1 ? stringValue.split('.') : [ stringValue, ''];
    }

    if (precision === 0) {
        return beforePoint;
    } else if (afterPoint.length > precision) {
        return `${beforePoint}.${afterPoint.substr(0, precision)}`;
    } else {
        return `${beforePoint}.${afterPoint}${'0'.repeat(precision - afterPoint.length)}`;
    }
}

18 ve üzeri uzunluklar için hassasiyetin düzgün bir şekilde ele alınamayabileceğini unutmayın, örneğin 64 bit Chrome bunu yuvarlayacak veya numaranın uzunluğunu 18'de tutmak için "e +" / "e-" ekleyecektir.

Gerçek sayılar üzerinde işlem yapmak istiyorsanız, Math.sqrt(10, precision)ilk önce bunu çarpmak daha güvenlidir , hesaplamaları yapın, ardından sonucu çarpan değerine göre dalın.

Misal:

0.06 + 0.01olduğu 0.06999999999999999ve yuvarlama değil her biçimlendirme işlevi onu keser 0.06hassasiyet için 2.

Ancak çarpan ve bölücü ile aynı işlemi gerçekleştirirseniz: (0.06 * 100 + 0.01 * 100) / 100elde edersiniz 0.07.

Bu nedenle, javascript'teki gerçek sayılarla, özellikle de para hesaplarken, bu çarpanı / bölücüyü kullanmak çok önemlidir ...