Làm thế nào để làm tròn số trong Javascript?

Tôi muốn sử dụng Javascript để làm tròn số. Vì số là tiền tệ, tôi muốn nó làm tròn như trong các ví dụ này (2 điểm thập phân):

• 192.168 => 192.20
• 192.11 => 192.20
• 192,21 => 192,30
• 192,26 => 192,30
• 192,20 => 192,20

Làm thế nào để đạt được điều này bằng Javascript? Hàm Javascript tích hợp sẽ làm tròn số dựa trên logic tiêu chuẩn (ít hơn và nhiều hơn 5 để làm tròn).

/**
 * @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

Hơi muộn nhưng, có thể tạo ra một chức năng javascript có thể sử dụng lại cho mục đích này:

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

Gọi hàm là

alert(roundNumber(192.168,2));

Làm tròn bình thường sẽ hoạt động với một tinh chỉnh nhỏ:

Math.round(price * 10)/10

và nếu bạn muốn giữ định dạng tiền tệ, bạn có thể sử dụng phương thức Số .toFixed()

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

Mặc dù điều này sẽ làm cho nó thành Chuỗi =)

Rất gần với câu trả lời của TheEye , nhưng tôi thay đổi một điều nhỏ để làm cho nó hoạt động:

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

OP mong đợi hai điều:
A. làm tròn lên phần mười cao hơn và
B. hiển thị số 0 ở vị trí thứ một trăm (một nhu cầu điển hình với tiền tệ).

Đáp ứng cả hai yêu cầu dường như cần một phương pháp riêng cho từng điều trên. Đây là một cách tiếp cận dựa trên câu trả lời được đề xuất của suryakiran:

//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

Lưu ý quan trọng: giải pháp này tạo ra một kết quả rất khác với số âm và số mũ.

Để so sánh giữa câu trả lời này và hai câu hỏi rất giống nhau, hãy xem 2 cách tiếp cận sau đây. Cái đầu tiên chỉ đơn giản là làm tròn đến một phần trăm gần nhất mỗi thông thường, và cái thứ hai chỉ đơn giản là làm tròn đến một phần trăm gần nhất (lớn hơn).

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

ok, điều này đã được trả lời, nhưng tôi nghĩ bạn có thể muốn xem câu trả lời của tôi gọi hàm math.pow () một lần. Tôi đoán tôi thích giữ những thứ KHÔ.

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

Nó là loại đặt tất cả cùng nhau. Thay thế Math.round () bằng Math.ceil () thành làm tròn thay vì làm tròn, đó là điều OP muốn.

Hàm này giới hạn số thập phân không có số tròn

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

Tôi đã sử dụng câu trả lời @AndrewMarshall trong một thời gian dài, nhưng tìm thấy một số trường hợp cạnh. Các xét nghiệm sau không vượt qua:

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

Đây là những gì tôi sử dụng để làm tròn chính xác:

// 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

Nguồn: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round

parseInt luôn làm tròn xuống soo .....

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

làm parseInt () + 1