Javascript'te bir sayı nasıl yuvarlanır?

Bir sayıyı yuvarlamak için Javascript kullanmak istiyorum. Sayı para birimi olduğundan, bu örneklerde olduğu gibi yuvarlanmasını istiyorum (2 ondalık sayı):

• 192.168 => 192.20
• 192.11 => 192.20
• 192.21 => 192.30
• 192.26 => 192.30
• 192.20 => 192.20

Javascript kullanarak bunu nasıl başarabilirim? Yerleşik Javascript işlevi, sayıyı standart mantığa göre yuvarlar (yuvarlamak için 5'ten az ve daha fazla).

/**
 * @param num The number to round
 * @param precision The number of decimal places to preserve
 */
function roundUp(num, precision) {
  precision = Math.pow(10, precision)
  return Math.ceil(num * precision) / precision
}

roundUp(192.168, 1) //=> 192.2

Biraz geç ama, bu amaçla yeniden kullanılabilir bir javascript işlevi oluşturabilirsiniz:

// Arguments: number to round, number of decimal places
function roundNumber(rnum, rlength) { 
    var newnumber = Math.round(rnum * Math.pow(10, rlength)) / Math.pow(10, rlength);
    return newnumber;
}

İşlevi şu şekilde çağır:

alert(roundNumber(192.168,2));

Normal yuvarlama küçük bir değişiklikle çalışır:

Math.round(price * 10)/10

ve para birimi biçimini korumak istiyorsanız Sayı yöntemini kullanabilirsiniz .toFixed()

(Math.round(price * 10)/10).toFixed(2)

Rağmen bu bir String =) yapacak

TheEye cevabına çok yakın , ama çalışmasını sağlamak için küçük bir şey değiştiriyorum:

var num = 192.16;
    
console.log(    Math.ceil(num * 10) / 10    );

OP iki şey bekliyor:
A. daha yüksek ondalık sayılara yuvarlamak ve
B. yüzüncü yerde sıfır göstermek için (para birimi ile tipik bir ihtiyaç).

Her iki gereksinimin karşılanması, yukarıdakilerin her biri için ayrı bir yöntem gerektiriyor gibi görünmektedir. Suryakiran'ın önerdiği cevabı temel alan bir yaklaşım:

//Arguments: number to round, number of decimal places.

function roundPrice(rnum, rlength) {
    var newnumber = Math.ceil(rnum * Math.pow(10, rlength-1)) / Math.pow(10, rlength-1);
    var toTenths = newnumber.toFixed(rlength);
    return toTenths;
}

alert(roundPrice(678.91011,2)); // returns 679.00
alert(roundPrice(876.54321,2)); // returns 876.60

Önemli not: bu çözüm negatif ve üstel sayılarla çok farklı bir sonuç üretir.

Bu cevap ile çok benzer iki cevap arasında karşılaştırma yapmak için aşağıdaki 2 yaklaşıma bakınız. Birincisi her zamanki en yakın yüzüncü yüzyıla yuvarlar ve ikincisi sadece en yakın yüzüncü yüzeye (daha büyük) yuvarlar.

function roundNumber(rnum, rlength) { 
    var newnumber = Math.round(rnum * Math.pow(10, rlength)) / Math.pow(10, rlength);
    return newnumber;
}

alert(roundNumber(678.91011,2)); // returns 678.91

function ceilNumber(rnum, rlength) { 
    var newnumber = Math.ceil(rnum * Math.pow(10, rlength)) / Math.pow(10, rlength);
    return newnumber;
}

alert(ceilNumber(678.91011,2)); // returns 678.92

tamam, bu cevaplandı, ama bir kere math.pow () işlevini çağıran cevabımı görmek isteyebileceğinizi düşündüm. Sanırım şeyleri KURU tutmayı seviyorum.

function roundIt(num, precision) {
    var rounder = Math.pow(10, precision);
    return (Math.round(num * rounder) / rounder).toFixed(precision)
};

Her şeyi bir araya getiriyor. OP'nin istediği yuvarlama yerine yuvarlamak için Math.round () yerine Math.ceil () kullanın.

bu fonksiyon, ondalık sayı olmadan ondalık sınırı

function limitDecimal(num,decimal){
     return num.toString().substring(0, num.toString().indexOf('.')) + (num.toString().substr(num.toString().indexOf('.'), decimal+1));
}

@AndrewMarshall cevabını uzun süredir kullanıyorum, ancak bazı uç durumlar buldum. Aşağıdaki testler geçmez:

equals(roundUp(9.69545, 4), 9.6955);
equals(roundUp(37.760000000000005, 4), 37.76);
equals(roundUp(5.83333333, 4), 5.8333);

İşte şimdi yukarı doğru davranmak için kullandığım şey:

// Closure
(function() {
  /**
   * Decimal adjustment of a number.
   *
   * @param {String}  type  The type of adjustment.
   * @param {Number}  value The number.
   * @param {Integer} exp   The exponent (the 10 logarithm of the adjustment base).
   * @returns {Number} The adjusted value.
   */
  function decimalAdjust(type, value, exp) {
    // If the exp is undefined or zero...
    if (typeof exp === 'undefined' || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // If the value is not a number or the exp is not an integer...
    if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
      return NaN;
    }
    // If the value is negative...
    if (value < 0) {
      return -decimalAdjust(type, -value, exp);
    }
    // Shift
    value = value.toString().split('e');
    value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
    // Shift back
    value = value.toString().split('e');
    return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
  }

  // Decimal round
  if (!Math.round10) {
    Math.round10 = function(value, exp) {
      return decimalAdjust('round', value, exp);
    };
  }
  // Decimal floor
  if (!Math.floor10) {
    Math.floor10 = function(value, exp) {
      return decimalAdjust('floor', value, exp);
    };
  }
  // Decimal ceil
  if (!Math.ceil10) {
    Math.ceil10 = function(value, exp) {
      return decimalAdjust('ceil', value, exp);
    };
  }
})();

// Round
Math.round10(55.55, -1);   // 55.6
Math.round10(55.549, -1);  // 55.5
Math.round10(55, 1);       // 60
Math.round10(54.9, 1);     // 50
Math.round10(-55.55, -1);  // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1);      // -50
Math.round10(-55.1, 1);    // -60
Math.round10(1.005, -2);   // 1.01 -- compare this with Math.round(1.005*100)/100 above
Math.round10(-1.005, -2);  // -1.01
// Floor
Math.floor10(55.59, -1);   // 55.5
Math.floor10(59, 1);       // 50
Math.floor10(-55.51, -1);  // -55.6
Math.floor10(-51, 1);      // -60
// Ceil
Math.ceil10(55.51, -1);    // 55.6
Math.ceil10(51, 1);        // 60
Math.ceil10(-55.59, -1);   // -55.5
Math.ceil10(-59, 1);       // -50

Kaynak: https://developer.mozilla.org/tr-TR/docs/Web/JavaScript/Reference/Global_Objects/Math/round

parseInt her zaman soo aşağı yuvarlar .....

console.log(parseInt(5.8)+1);

parseInt () + 1 yap