JavaScript'te ondalık sayıları kesin (yuvarlamayın)

Ondalık sayıları ondalık basamaklar halinde kesmeye çalışıyorum. Bunun gibi bir şey:

5.467   -> 5.46  
985.943 -> 985.94

toFixed(2)hemen hemen doğru olanı yapar ama değeri yuvarlar. Değerin yuvarlanmasına ihtiyacım yok. Umarım bu javascript ile mümkündür.

upd :

Sonuçta, ne kadar telafi etmeye çalışırsanız çalışın, yuvarlanan böcekler sizi her zaman rahatsız edecek. Bu nedenle, sayılar tam olarak ondalık gösterimle temsil edilerek sorun aşılmalıdır.

Number.prototype.toFixedDown = function(digits) {
    var re = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)"),
        m = this.toString().match(re);
    return m ? parseFloat(m[1]) : this.valueOf();
};

[   5.467.toFixedDown(2),
    985.943.toFixedDown(2),
    17.56.toFixedDown(2),
    (0).toFixedDown(1),
    1.11.toFixedDown(1) + 22];

// [5.46, 985.94, 17.56, 0, 23.1]

Başkalarının derlemesine dayanan eski hataya açık çözüm:

Number.prototype.toFixedDown = function(digits) {
  var n = this - Math.pow(10, -digits)/2;
  n += n / Math.pow(2, 53); // added 1360765523: 17.56.toFixedDown(2) === "17.56"
  return n.toFixed(digits);
}

Dogbert'in cevabı iyidir, ancak kodunuzun negatif sayılarla uğraşması gerekiyorsa, Math.floorkendi başına beklenmedik sonuçlar verebilir.

Örneğin Math.floor(4.3) = 4, amaMath.floor(-4.3) = -5

Tutarlı sonuçlar elde etmek için bunun gibi bir yardımcı işlev kullanın:

truncateDecimals = function (number) {
    return Math[number < 0 ? 'ceil' : 'floor'](number);
};

// Applied to Dogbert's answer:
var a = 5.467;
var truncated = truncateDecimals(a * 100) / 100; // = 5.46

İşte bu işlevin daha kullanışlı bir versiyonu:

truncateDecimals = function (number, digits) {
    var multiplier = Math.pow(10, digits),
        adjustedNum = number * multiplier,
        truncatedNum = Math[adjustedNum < 0 ? 'ceil' : 'floor'](adjustedNum);

    return truncatedNum / multiplier;
};

// Usage:
var a = 5.467;
var truncated = truncateDecimals(a, 2); // = 5.46

// Negative digits:
var b = 4235.24;
var truncated = truncateDecimals(b, -2); // = 4200

Bu istenmeyen bir davranışsa, Math.absilk satıra bir çağrı ekleyin :

var multiplier = Math.pow(10, Math.abs(digits)),

DÜZENLEME: shendz doğru bir şekilde bu çözümün kullanılmasının a = 17.56yanlış üreteceğine işaret ediyor 17.55. Bunun neden olduğu hakkında daha fazla bilgi için Her Bilgisayar Bilimcisinin Kayan Nokta Aritmetiği Hakkında Bilmesi Gerekenler'i okuyun . Ne yazık ki, tüm kayan nokta hatası kaynaklarını ortadan kaldıran bir çözüm yazmak, javascript ile oldukça zordur. Başka bir dilde tamsayılar veya belki bir Ondalık türü kullanırsınız, ancak javascript ile ...

Bu çözüm % 100 doğru olmalı , ancak aynı zamanda daha yavaş olacaktır:

function truncateDecimals (num, digits) {
    var numS = num.toString(),
        decPos = numS.indexOf('.'),
        substrLength = decPos == -1 ? numS.length : 1 + decPos + digits,
        trimmedResult = numS.substr(0, substrLength),
        finalResult = isNaN(trimmedResult) ? 0 : trimmedResult;

    return parseFloat(finalResult);
}

Hıza ihtiyaç duyan ancak aynı zamanda kayan nokta hatalarından kaçınmak isteyenler için BigDecimal.js gibi bir şey deneyin . Bu SO sorusunda diğer javascript BigDecimal kitaplıklarını bulabilirsiniz: "İyi bir Javascript BigDecimal kitaplığı var mı?" ve işte Javascript matematik kitaplıkları hakkında güzel bir blog yazısı

var a = 5.467;
var truncated = Math.floor(a * 100) / 100; // = 5.46

Yuvarlamayı, toFixed için 0,5 çıkararak düzeltebilirsiniz, örneğin

(f - 0.005).toFixed(2)

Düşünün çift tildeli yararlanarak:~~ .

Numarayı al. Ondalık basamaktan sonra anlamlı basamaklarla çarpın, böylece ile sıfır basamak kesebilirsiniz~~ . Bu çarpanı tekrar bölün. Kar.

function truncator(numToTruncate, intDecimalPlaces) {    
    var numPower = Math.pow(10, intDecimalPlaces); // "numPowerConverter" might be better
    return ~~(numToTruncate * numPower)/numPower;
}

~~Aramayı parantez içinde sarmalamaya direnmeye çalışıyorum ; Operasyon sırasının bunun doğru çalışmasını sağlaması gerektiğine inanıyorum.

alert(truncator(5.1231231, 1)); // is 5.1

alert(truncator(-5.73, 1)); // is -5.7

alert(truncator(-5.73, 0)); // is -5

JSFiddle bağlantısı .

DÜZENLEME: Geriye dönüp baktığımda, istemeden de ondalık sayının solunu yuvarlamak için davaları ele aldım.

alert(truncator(4343.123, -2)); // gives 4300.

Mantık, bu kullanımı arayan biraz tuhaftır ve hızlı bir yeniden düzenleme işleminden yararlanabilir. Ama yine de çalışıyor. İyiden daha şanslı.

Güzel tek satırlık çözüm:

function truncate (num, places) {
  return Math.trunc(num * Math.pow(10, places)) / Math.pow(10, places);
}

O halde şu numarayı arayın:

truncate(3.5636232, 2); // returns 3.56
truncate(5.4332312, 3); // returns 5.433
truncate(25.463214, 4); // returns 25.4632

|Basit olduğu ve iyi çalıştığı için kullanarak bir cevap vereceğimi düşündüm .

truncate = function(number, places) {
  var shift = Math.pow(10, places);

  return ((number * shift) | 0) / shift;
};

Bitsel operatörler kullanarak kırpın:

~~0.5 === 0
~~(-0.5) === 0
~~14.32794823 === 14
~~(-439.93) === -439

@ Dogbert'in cevabı Math.trunc, yuvarlama yerine kısaltan ile geliştirilebilir .

Yuvarlama ve kesme arasında bir fark vardır. Kesmek, açıkça bu sorunun aradığı davranıştır. Truncate (-3.14) ararsam ve -4 geri alırsam, buna kesinlikle istenmeyen derim. - @NickKnowlson

var a = 5.467;
var truncated = Math.trunc(a * 100) / 100; // = 5.46

var a = -5.467;
var truncated = Math.trunc(a * 100) / 100; // = -5.46

Daha kısa bir yöntem kullanarak bir cevap yazdım. İşte bulduğum şey

function truncate(value, precision) {
    var step = Math.pow(10, precision || 0);
    var temp = Math.trunc(step * value);

    return temp / step;
}

Yöntem şu şekilde kullanılabilir

truncate(132456.25456789, 5)); // Output: 132456.25456
truncate(132456.25456789, 3)); // Output: 132456.254
truncate(132456.25456789, 1)); // Output: 132456.2   
truncate(132456.25456789));    // Output: 132456

Veya daha kısa bir sözdizimi istiyorsanız, işte burada

function truncate(v, p) {
    var s = Math.pow(10, p || 0);
    return Math.trunc(s * v) / s;
}

Number.prototype.trim = function(decimals) {
    var s = this.toString();
    var d = s.split(".");
    d[1] = d[1].substring(0, decimals);
    return parseFloat(d.join("."));
}

console.log((5.676).trim(2)); //logs 5.67

Bu işlevin basit bir çözüm olabileceğini düşünüyorum:

function trunc(decimal,n=2){
  let x = decimal + ''; // string 
  return x.lastIndexOf('.')>=0?parseFloat(x.substr(0,x.lastIndexOf('.')+(n+1))):decimal; // You can use indexOf() instead of lastIndexOf()
}

console.log(trunc(-241.31234,2));
console.log(trunc(241.312,5));
console.log(trunc(-241.233));
console.log(trunc(241.2,0));  
console.log(trunc(241));

Bir sorun buldum: sonraki durumu düşünürsek: 2.1 veya 1.2 veya -6.4

Ya her zaman 3 ondalık veya iki veya daha fazla ondalık istersen, sağdaki baştaki sıfırları tamamlaman gerekir.

// 3 decimals numbers
0.5 => 0.500

// 6 decimals
0.1 => 0.10000

// 4 decimales
-2.1 => -2.1000

// truncate to 3 decimals
3.11568 => 3.115

Bu, Nick Knowlson'ın sabit işlevidir.

function truncateDecimals (num, digits) 
{
    var numS = num.toString();
    var decPos = numS.indexOf('.');
    var substrLength = decPos == -1 ? numS.length : 1 + decPos + digits;
    var trimmedResult = numS.substr(0, substrLength);
    var finalResult = isNaN(trimmedResult) ? 0 : trimmedResult;

    // adds leading zeros to the right
    if (decPos != -1){
        var s = trimmedResult+"";
        decPos = s.indexOf('.');
        var decLength = s.length - decPos;

            while (decLength <= digits){
                s = s + "0";
                decPos = s.indexOf('.');
                decLength = s.length - decPos;
                substrLength = decPos == -1 ? s.length : 1 + decPos + digits;
            };
        finalResult = s;
    }
    return finalResult;
};

https://jsfiddle.net/huttn155/7/

function toFixed(number, digits) {
    var reg_ex = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)")
    var array = number.toString().match(reg_ex);
    return array ? parseFloat(array[1]) : number.valueOf()
}

var test = 10.123456789
var __fixed = toFixed(test, 6)
console.log(__fixed)
// => 10.123456

@ Kirilloid tarafından verilen cevap doğru cevap gibi görünüyor, ancak ana kodun güncellenmesi gerekiyor. Çözümü negatif sayılarla ilgilenmiyor (birisi yorum bölümünde bahsetti ancak ana kodda güncellenmedi).

Bunu eksiksiz bir son test edilmiş çözüme güncellemek:

Number.prototype.toFixedDown = function(digits) {
    var re = new RegExp("([-]*\\d+\\.\\d{" + digits + "})(\\d)"),
    m = this.toString().match(re);
    return m ? parseFloat(m[1]) : this.valueOf();
};

Örnek Kullanım:

var x = 3.1415629;
Logger.log(x.toFixedDown(2)); //or use whatever you use to log

Fiddle: JS Numarası Yuvarlama

Not: Bu çözüm hakkında yorum yapmak için yeterli repo yok.

Burada, sayıyı 2 ondalık basamağa kadar kesmek için basit ama çalışan bir işlev.

           function truncateNumber(num) {
                var num1 = "";
                var num2 = "";
                var num1 = num.split('.')[0];
                num2 = num.split('.')[1];
                var decimalNum = num2.substring(0, 2);
                var strNum = num1 +"."+ decimalNum;
                var finalNum = parseFloat(strNum);
                return finalNum;
            }

Ortaya çıkan tür bir sayı olarak kalır ...

/* Return the truncation of n wrt base */
var trunc = function(n, base) {
    n = (n / base) | 0;
    return base * n;
};
var t = trunc(5.467, 0.01);

Lodash birkaç Matematik yarar yöntemler bulduğunu söyledi can yuvarlak , zemin ve tavan yapmak , belirli bir ondalık hassas bir sayı. Bu, sondaki sıfırları bırakır.

Bir sayının üssünü kullanarak ilginç bir yaklaşım sergiliyorlar. Görünüşe göre bu, yuvarlama sorunlarını ortadan kaldırıyor.

(Not: funcbir Math.roundya da ceilya da flooraşağıda kodunda)

// Shift with exponential notation to avoid floating-point issues.
var pair = (toString(number) + 'e').split('e'),
    value = func(pair[0] + 'e' + (+pair[1] + precision));

pair = (toString(value) + 'e').split('e');
return +(pair[0] + 'e' + (+pair[1] - precision));

Kaynak koduna bağlantı

İşte konuyla ilgili görüşüm:

convert.truncate = function(value, decimals) {
  decimals = (decimals === undefined ? 0 : decimals);
  return parseFloat((value-(0.5/Math.pow(10, decimals))).toFixed(decimals),10);
};

Bu sadece biraz daha ayrıntılı bir versiyonu

(f - 0.005).toFixed(2)

Çözüm olarak işaretlenen, bugüne kadar bulduğum daha iyi çözüm, ancak 0 ile ilgili ciddi bir problemi var (örneğin, 0.toFixedDown (2) -0.01 verir). Bu yüzden şunu kullanmanızı öneririm:

Number.prototype.toFixedDown = function(digits) {
  if(this == 0) {
    return 0;
  }
  var n = this - Math.pow(10, -digits)/2;
  n += n / Math.pow(2, 53); // added 1360765523: 17.56.toFixedDown(2) === "17.56"
  return n.toFixed(digits);
}

İşte kullandığım şey:

var t = 1;
for (var i = 0; i < decimalPrecision; i++)
    t = t * 10;

var f = parseFloat(value);
return (Math.floor(f * t)) / t;

const TO_FIXED_MAX = 100;

function truncate(number, decimalsPrecison) {
  // make it a string with precision 1e-100
  number = number.toFixed(TO_FIXED_MAX);

  // chop off uneccessary digits
  const dotIndex = number.indexOf('.');
  number = number.substring(0, dotIndex + decimalsPrecison + 1);

  // back to a number data type (app specific)
  return Number.parseFloat(number);
}

// example
truncate(0.00000001999, 8);
0.00000001

ile çalışır:

• negatif sayılar
• çok küçük sayılar (Number.EPSILON duyarlılığı)

sadece benim için çalışan basit bir çözüme işaret etmek için

onu dizeye dönüştür ve sonra yeniden ifade et ...

var number = 123.45678;
var number_s = '' + number;
var number_truncated_s = number_s.match(/\d*\.\d{4}/)[0]
var number_truncated = parseFloat(number_truncated_s)

Kısaltılabilir

var number_truncated = parseFloat(('' + 123.4568908).match(/\d*\.\d{4}/)[0])

İşte istediğinizi yapan bir ES6 kodu

const truncateTo = (unRouned, nrOfDecimals = 2) => {
      const parts = String(unRouned).split(".");

      if (parts.length !== 2) {
          // without any decimal part
        return unRouned;
      }

      const newDecimals = parts[1].slice(0, nrOfDecimals),
        newString = `${parts[0]}.${newDecimals}`;

      return Number(newString);
    };

// your examples 

 console.log(truncateTo(5.467)); // ---> 5.46

 console.log(truncateTo(985.943)); // ---> 985.94

// other examples 

 console.log(truncateTo(5)); // ---> 5

 console.log(truncateTo(-5)); // ---> -5

 console.log(truncateTo(-985.943)); // ---> -985.94

Number.prototype.truncate = function(places) {
  var shift = Math.pow(10, places);

  return Math.trunc(this * shift) / shift;
};

Dizelerle çalışabilirsiniz. "." Olup olmadığını kontrol eder. var ve sonra dizenin bir kısmını kaldırır.

kesik (7.88, 1) -> 7.8

kesik (7.889, 2) -> 7.89

kesik (-7.88, 1) -> -7.88

function  truncate(number, decimals) {
    const tmp = number + '';
    if (tmp.indexOf('.') > -1) {
        return +tmp.substr(0 , tmp.indexOf('.') + decimals+1 );
    } else {
        return +number
    }
 }

Bu kadar temelde basit bir soruya neden bu kadar çok farklı yanıt olduğu konusunda biraz kafam karıştı; Bakmaya değer görünen sadece iki yaklaşım var. Https://jsbench.me/ kullanarak hız farkını görmek için hızlı bir kıyaslama yaptım .

Şu anda (26/9/2020) yanıt olarak işaretlenen çözüm budur:

function truncate(n, digits) {
    var re = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)"),
        m = n.toString().match(re);
    return m ? parseFloat(m[1]) : n.valueOf();
};

[   truncate(5.467,2),
    truncate(985.943,2),
    truncate(17.56,2),
    truncate(0, 1),
    truncate(1.11, 1) + 22];

Ancak, bu genellikle çok verimli değildir dize ve regex şeyler, yapıyor ve yapacak bir Math.trunc işlevi vardır tam olarak OP sadece ondalık değil ile istediği. Bu nedenle, aynı şeyi elde etmek için bunu ve biraz fazladan aritmetiği kolayca kullanabilirsiniz.

İşte bu iş parçacığında bulduğum başka bir çözüm, kullanacağım çözüm:

function truncate(n, digits) {
    var step = Math.pow(10, digits || 0);
    var temp = Math.trunc(step * n);

    return temp / step;
}

[   truncate(5.467,2),
    truncate(985.943,2),
    truncate(17.56,2),
    truncate(0, 1),
    truncate(1.11, 1) + 22];
    

İlk yöntem ikinciye göre "% 99,92 daha yavaş", bu nedenle ikincisi kesinlikle kullanmanızı tavsiye edeceğim yöntemdir .

Tamam, işten kaçınmanın başka yollarını bulmaya geri dönelim ...