У мене є цей рядок коду, який округляє мої числа до двох знаків після коми. Але я отримую такі цифри: 10,8, 2,4 і т. Д. Це не моє уявлення про два знаки після коми, як я можу вдосконалити наступне?

Math.round(price*Math.pow(10,2))/Math.pow(10,2);

Я хочу, щоб такі цифри, як 10.80, 2.40, і т. Д. Використання jQuery зі мною добре.

Щоб відформатувати число за допомогою позначення фіксованої точки, ви можете просто скористатися методом toFixed :

(10.8).toFixed(2); // "10.80"

var num = 2.4;
alert(num.toFixed(2)); // "2.40"

Зверніть увагу, що toFixed()повертає рядок.

ВАЖЛИВО : Зауважте, що toFixed не округляє 90% часу, він поверне закруглене значення, але для багатьох випадків це не працює.

Наприклад:

2.005.toFixed(2) === "2.00"

ОНОВЛЕННЯ:

Сьогодні ви можете використовувати Intl.NumberFormatконструктор. Це частина специфікації API інтернаціоналізації ECMAScript (ECMA402). Він має досить хорошу підтримку браузера , в тому числі навіть IE11, і вона повністю підтримується в Node.js .

const formatter = new Intl.NumberFormat('en-US', {
   minimumFractionDigits: 2,      
   maximumFractionDigits: 2,
});

console.log(formatter.format(2.005)); // "2.01"
console.log(formatter.format(1.345)); // "1.35"

Можна також скористатися toLocaleStringметодом, який внутрішньо використовуватиме IntlAPI:

const format = (num, decimals) => num.toLocaleString('en-US', {
   minimumFractionDigits: 2,      
   maximumFractionDigits: 2,
});


console.log(format(2.005)); // "2.01"
console.log(format(1.345)); // "1.35"

Цей API також надає вам широкий спектр варіантів форматування, наприклад, тисячі роздільників, символів валюти тощо.

Це стара тема, але все ще найкращі результати Google та запропоновані рішення поділяють ту саму проблему з десятковою комою з плаваючою комою. Ось (дуже загальна) функція, яку я використовую, завдяки MDN :

function round(value, exp) {
  if (typeof exp === 'undefined' || +exp === 0)
    return Math.round(value);

  value = +value;
  exp = +exp;

  if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(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));
}

Як ми бачимо, у нас таких проблем немає:

round(1.275, 2);   // Returns 1.28
round(1.27499, 2); // Returns 1.27

Ця щедрість також забезпечує деякі цікаві речі:

round(1234.5678, -2);   // Returns 1200
round(1.2345678e+2, 2); // Returns 123.46
round("123.45");        // Returns 123

Тепер, щоб відповісти на питання ОП, потрібно набрати:

round(10.8034, 2).toFixed(2); // Returns "10.80"
round(10.8, 2).toFixed(2);    // Returns "10.80"

Або для більш короткої, менш родової функції:

function round2Fixed(value) {
  value = +value;

  if (isNaN(value))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + 2) : 2)));

  // Shift back
  value = value.toString().split('e');
  return (+(value[0] + 'e' + (value[1] ? (+value[1] - 2) : -2))).toFixed(2);
}

Ви можете зателефонувати за допомогою:

round2Fixed(10.8034); // Returns "10.80"
round2Fixed(10.8);    // Returns "10.80"

Різні приклади та тести (завдяки @ tj-crowder !):

function round(value, exp) {
  if (typeof exp === 'undefined' || +exp === 0)
    return Math.round(value);

  value = +value;
  exp = +exp;

  if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(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));
}
function naive(value, exp) {
  if (!exp) {
    return Math.round(value);
  }
  var pow = Math.pow(10, exp);
  return Math.round(value * pow) / pow;
}
function test(val, places) {
  subtest(val, places);
  val = typeof val === "string" ? "-" + val : -val;
  subtest(val, places);
}
function subtest(val, places) {
  var placesOrZero = places || 0;
  var naiveResult = naive(val, places);
  var roundResult = round(val, places);
  if (placesOrZero >= 0) {
    naiveResult = naiveResult.toFixed(placesOrZero);
    roundResult = roundResult.toFixed(placesOrZero);
  } else {
    naiveResult = naiveResult.toString();
    roundResult = roundResult.toString();
  }
  $("<tr>")
    .append($("<td>").text(JSON.stringify(val)))
    .append($("<td>").text(placesOrZero))
    .append($("<td>").text(naiveResult))
    .append($("<td>").text(roundResult))
    .appendTo("#results");
}
test(0.565, 2);
test(0.575, 2);
test(0.585, 2);
test(1.275, 2);
test(1.27499, 2);
test(1234.5678, -2);
test(1.2345678e+2, 2);
test("123.45");
test(10.8034, 2);
test(10.8, 2);
test(1.005, 2);
test(1.0005, 2);

table {
  border-collapse: collapse;
}
table, td, th {
  border: 1px solid #ddd;
}
td, th {
  padding: 4px;
}
th {
  font-weight: normal;
  font-family: sans-serif;
}
td {
  font-family: monospace;
}

<table>
  <thead>
    <tr>
      <th>Input</th>
      <th>Places</th>
      <th>Naive</th>
      <th>Thorough</th>
    </tr>
  </thead>
  <tbody id="results">
  </tbody>
</table>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

Зазвичай я додаю це в мою особисту бібліотеку, і після деяких пропозицій та використання рішення @TIMINeutron також роблячи його пристосованим до десяткової довжини, це найкраще підходить:

function precise_round(num, decimals) {
   var t = Math.pow(10, decimals);   
   return (Math.round((num * t) + (decimals>0?1:0)*(Math.sign(num) * (10 / Math.pow(100, decimals)))) / t).toFixed(decimals);
}

працюватиме за винятками, про які повідомлялося.

Я не знаю, чому я не можу додати коментар до попередньої відповіді (можливо, я безнадійно сліпий, не знаю), але я придумав рішення, використовуючи відповідь @ Мігеля:

function precise_round(num,decimals) {
   return Math.round(num*Math.pow(10, decimals)) / Math.pow(10, decimals);
}

І два його коментарі (від @bighostkim та @Imre):

• Проблема з precise_round(1.275,2)неповерненням 1.28
• Проблема з тим, що precise_round(6,2)не повернутись 6.00 (як він хотів).

Моє остаточне рішення таке:

function precise_round(num,decimals) {
    var sign = num >= 0 ? 1 : -1;
    return (Math.round((num*Math.pow(10,decimals)) + (sign*0.001)) / Math.pow(10,decimals)).toFixed(decimals);
}

Як ви бачите, мені довелося додати трохи "виправлення" (це не те, що воно є, але оскільки Math.round втрачає - ви можете перевірити це на jsfiddle.net - це єдиний спосіб, який я знав, як "виправити" "це). Він додає 0,001 до вже доданого числа, тому він додає 1три 0s праворуч від десяткового значення. Тож воно має бути безпечним у використанні.

Після цього я додав .toFixed(decimal)завжди виводити число у правильному форматі (з потрібною кількістю десяткових знаків).

Так що це майже все. Використовуйте це добре;)

EDIT: додана функціональність до "виправлення" від'ємних чисел.

Один із способів бути 100% впевненим, що ви отримаєте число з 2 десятковою комою:

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

Якщо це спричиняє помилки округлення, ви можете використовувати наступне, як Джеймс пояснив у своєму коментарі:

(Math.round((num * 1000)/10)/100).toFixed(2)

toFixed (n) забезпечує n довжину після десяткової точки; toPrecision (x) забезпечує x загальну довжину.

Використовуйте цей метод нижче

// Example: toPrecision(4) when the number has 7 digits (3 before, 4 after)
    // It will round to the tenths place
    num = 500.2349;
    result = num.toPrecision(4); // result will equal 500.2

І якщо ви хочете, щоб номер був фіксованим, використовуйте

result = num.toFixed(2);

Я не знайшов точного рішення цієї проблеми, тому створив своє:

function inprecise_round(value, decPlaces) {
  return Math.round(value*Math.pow(10,decPlaces))/Math.pow(10,decPlaces);
}

function precise_round(value, decPlaces){
    var val = value * Math.pow(10, decPlaces);
    var fraction = (Math.round((val-parseInt(val))*10)/10);

    //this line is for consistency with .NET Decimal.Round behavior
    // -342.055 => -342.06
    if(fraction == -0.5) fraction = -0.6;

    val = Math.round(parseInt(val) + fraction) / Math.pow(10, decPlaces);
    return val;
}

Приклади:

function inprecise_round(value, decPlaces) {
  return Math.round(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

function precise_round(value, decPlaces) {
  var val = value * Math.pow(10, decPlaces);
  var fraction = (Math.round((val - parseInt(val)) * 10) / 10);

  //this line is for consistency with .NET Decimal.Round behavior
  // -342.055 => -342.06
  if (fraction == -0.5) fraction = -0.6;

  val = Math.round(parseInt(val) + fraction) / Math.pow(10, decPlaces);
  return val;
}

// This may produce different results depending on the browser environment
console.log("342.055.toFixed(2)         :", 342.055.toFixed(2)); // 342.06 on Chrome & IE10

console.log("inprecise_round(342.055, 2):", inprecise_round(342.055, 2)); // 342.05
console.log("precise_round(342.055, 2)  :", precise_round(342.055, 2));   // 342.06
console.log("precise_round(-342.055, 2) :", precise_round(-342.055, 2));  // -342.06

console.log("inprecise_round(0.565, 2)  :", inprecise_round(0.565, 2));   // 0.56
console.log("precise_round(0.565, 2)    :", precise_round(0.565, 2));     // 0.57

@heridev і я створили невелику функцію в jQuery.

Ви можете спробувати наступне:

HTML

<input type="text" name="one" class="two-digits"><br>
<input type="text" name="two" class="two-digits">​

jQuery

// apply the two-digits behaviour to elements with 'two-digits' as their class
$( function() {
    $('.two-digits').keyup(function(){
        if($(this).val().indexOf('.')!=-1){         
            if($(this).val().split(".")[1].length > 2){                
                if( isNaN( parseFloat( this.value ) ) ) return;
                this.value = parseFloat(this.value).toFixed(2);
            }  
         }            
         return this; //for chaining
    });
});

DEMO ONLINE:

http://jsfiddle.net/c4Wqn/

Проблема зі значеннями з плаваючою комою полягає в тому, що вони намагаються представляти нескінченну кількість (безперервних) значень з фіксованою кількістю біт. Отже, природно, в грі повинні бути певні втрати, і ви збираєтеся бути покусані якимись значеннями.

Якщо комп’ютер зберігає 1,275 як значення з плаваючою комою, він насправді не пам’ятатиме, був він 1,275 або 1,227499999999999993, або навіть 1,27500000000000002. Ці значення повинні дати різні результати після округлення до двох десяткових знаків, але вони не будуть, оскільки для комп'ютера вони виглядають абсолютно однаково після зберігання як значення з плаваючою комою, і немає можливості відновити втрачені дані. Будь-які подальші розрахунки лише акумулюють таку неточність.

Тож, якщо точність має значення, ви повинні уникати значень з плаваючою комою з самого початку. Найпростіші варіанти - це

• використовувати виділену бібліотеку
• використовувати рядки для зберігання та передачі значень (супроводжуються рядковими операціями)
• використовуйте цілі числа (наприклад, ви можете переходити близько сотих частин фактичної вашої вартості, наприклад, сума в центах замість суми в доларах)

Наприклад, використовуючи цілі числа для зберігання числа сотих, функція пошуку фактичного значення досить проста:

function descale(num, decimals) {
    var hasMinus = num < 0;
    var numString = Math.abs(num).toString();
    var precedingZeroes = '';
    for (var i = numString.length; i <= decimals; i++) {
        precedingZeroes += '0';
    }
    numString = precedingZeroes + numString;
    return (hasMinus ? '-' : '') 
        + numString.substr(0, numString.length-decimals) 
        + '.' 
        + numString.substr(numString.length-decimals);
}

alert(descale(127, 2));

За допомогою рядків вам знадобиться округлення, але це все ще керовано:

function precise_round(num, decimals) {
    var parts = num.split('.');
    var hasMinus = parts.length > 0 && parts[0].length > 0 && parts[0].charAt(0) == '-';
    var integralPart = parts.length == 0 ? '0' : (hasMinus ? parts[0].substr(1) : parts[0]);
    var decimalPart = parts.length > 1 ? parts[1] : '';
    if (decimalPart.length > decimals) {
        var roundOffNumber = decimalPart.charAt(decimals);
        decimalPart = decimalPart.substr(0, decimals);
        if ('56789'.indexOf(roundOffNumber) > -1) {
            var numbers = integralPart + decimalPart;
            var i = numbers.length;
            var trailingZeroes = '';
            var justOneAndTrailingZeroes = true;
            do {
                i--;
                var roundedNumber = '1234567890'.charAt(parseInt(numbers.charAt(i)));
                if (roundedNumber === '0') {
                    trailingZeroes += '0';
                } else {
                    numbers = numbers.substr(0, i) + roundedNumber + trailingZeroes;
                    justOneAndTrailingZeroes = false;
                    break;
                }
            } while (i > 0);
            if (justOneAndTrailingZeroes) {
                numbers = '1' + trailingZeroes;
            }
            integralPart = numbers.substr(0, numbers.length - decimals);
            decimalPart = numbers.substr(numbers.length - decimals);
        }
    } else {
        for (var i = decimalPart.length; i < decimals; i++) {
            decimalPart += '0';
        }
    }
    return (hasMinus ? '-' : '') + integralPart + (decimals > 0 ? '.' + decimalPart : '');
}

alert(precise_round('1.275', 2));
alert(precise_round('1.27499999999999993', 2));

Зауважте, що ця функція закріплюється до найближчого, пов'язаного з нулем , тоді як IEEE 754 рекомендує округлення до найближчого, прив'язується навіть до поведінки за замовчуванням для операцій з плаваючою комою. Такі модифікації залишаються читачем як вправа :)

Ось простий

function roundFloat(num,dec){
    var d = 1;
    for (var i=0; i<dec; i++){
        d += "0";
    }
    return Math.round(num * d) / d;
}

Використовуйте як alert(roundFloat(1.79209243929,4));

Jsfiddle

Заокруглюйте десяткове значення, а потім використовуйте toFixed(x)для очікуваної цифри.

function parseDecimalRoundAndFixed(num,dec){
  var d =  Math.pow(10,dec);
  return (Math.round(num * d) / d).toFixed(dec);
}

Дзвінок

parseDecimalRoundAndFixed (10.800243929,4) => 10,80 парсеDecimalRoundAndFixed (10.807243929,2) => 10,81

Закругніть вниз

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

Закруглюємо

function round_up(value, decPlaces) {
    return Math.ceil(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

Круглий найближчий

function round_nearest(value, decPlaces) {
    return Math.round(value * Math.pow(10, decPlaces)) / Math.pow(10, decPlaces);
}

Об’єднані https://stackoverflow.com/a/7641824/1889449 та https://www.kirupa.com/html5/rounding_numbers_in_javascript.htm Дякую їм.

Ось моє однорядкове рішення: Number((yourNumericValueHere).toFixed(2));

Ось що відбувається:

1) По-перше, ви застосовуєте .toFixed(2)число, яке ви хочете округлити десятковими знаками. Зауважте, що це перетворить значення в рядок з числа. Отже, якщо ви використовуєте Typescript, він видасть помилку на зразок цієї:

"Тип" рядок "не призначається типу" номер ""

2) Щоб повернути числове значення або перетворити рядок у числове значення, просто застосуйте Number()функцію до цього так званого 'рядкового' значення.

Для уточнення дивіться приклад нижче:

ПРИКЛАД: Я маю суму, яка містить до 5 цифр у десяткових знаках, і я хотів би скоротити її до двох знаків після коми. Я це роблю так:

var price = 0.26453;
var priceRounded = Number((price).toFixed(2));
console.log('Original Price: ' + price);
console.log('Price Rounded: ' + priceRounded);

Помістіть наступне в деякому глобальному масштабі:

Number.prototype.getDecimals = function ( decDigCount ) {
   return this.toFixed(decDigCount);
}

а потім спробуйте :

var a = 56.23232323;
a.getDecimals(2); // will return 56.23

Оновлення

Зауважте, що toFixed()може працювати лише кількість десяткових знаків між 0-20т. Е. a.getDecimals(25)Може генерувати помилку javascript, так що для розміщення ви можете додати додаткову перевірку, тобто

Number.prototype.getDecimals = function ( decDigCount ) {
   return ( decDigCount > 20 ) ? this : this.toFixed(decDigCount);
}

Number(((Math.random() * 100) + 1).toFixed(2))

це поверне випадкове число від 1 до 100 округлених до 2 знаків після коми.

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

Це працювало для мене: Округлення десяткових знаків у JavaScript

Використовуючи цю відповідь за посиланням: https://stackoverflow.com/a/21029698/454827

Я будую функцію для отримання динамічних чисел десяткових знаків:

function toDec(num, dec)
{
        if(typeof dec=='undefined' || dec<0)
                dec = 2;

        var tmp = dec + 1;
        for(var i=1; i<=tmp; i++)
                num = num * 10;

        num = num / 10;
        num = Math.round(num);
        for(var i=1; i<=dec; i++)
                num = num / 10;

        num = num.toFixed(dec);

        return num;
}

ось робочий приклад: https://jsfiddle.net/wpxLduLc/

З цими прикладами ви все одно отримаєте помилку при спробі округлити число 1.005, рішення - або використовувати бібліотеку типу Math.js, або цю функцію:

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

Я отримав кілька ідей з цього допису кілька місяців тому, але жодна з відповідей тут, ні відповіді з інших дописів / блогів не змогли впоратися з усіма сценаріями (наприклад, негативні номери та деякі "щасливі номери" наш тестер знайшов). Зрештою, наш тестер не знайшов жодної проблеми з цим методом нижче. Вставлення фрагмента мого коду:

fixPrecision: function (value) {
    var me = this,
        nan = isNaN(value),
        precision = me.decimalPrecision;

    if (nan || !value) {
        return nan ? '' : value;
    } else if (!me.allowDecimals || precision <= 0) {
        precision = 0;
    }

    //[1]
    //return parseFloat(Ext.Number.toFixed(parseFloat(value), precision));
    precision = precision || 0;
    var negMultiplier = value < 0 ? -1 : 1;

    //[2]
    var numWithExp = parseFloat(value + "e" + precision);
    var roundedNum = parseFloat(Math.round(Math.abs(numWithExp)) + 'e-' + precision) * negMultiplier;
    return parseFloat(roundedNum.toFixed(precision));
},

У мене також є коментарі до коду (вибачте, що я вже забув усі деталі) ... Я публікую тут свою відповідь для подальшої довідки:

9.995 * 100 = 999.4999999999999
Whereas 9.995e2 = 999.5
This discrepancy causes Math.round(9.995 * 100) = 999 instead of 1000.
Use e notation instead of multiplying /dividing by Math.Pow(10,precision).

Я вирішую проблему модифікатора. Підтримка лише 2 десятків.

$(function(){
  //input number only.
  convertNumberFloatZero(22); // output : 22.00
  convertNumberFloatZero(22.5); // output : 22.50
  convertNumberFloatZero(22.55); // output : 22.55
  convertNumberFloatZero(22.556); // output : 22.56
  convertNumberFloatZero(22.555); // output : 22.55
  convertNumberFloatZero(22.5541); // output : 22.54
  convertNumberFloatZero(22222.5541); // output : 22,222.54

  function convertNumberFloatZero(number){
	if(!$.isNumeric(number)){
		return 'NaN';
	}
	var numberFloat = number.toFixed(3);
	var splitNumber = numberFloat.split(".");
	var cNumberFloat = number.toFixed(2);
	var cNsplitNumber = cNumberFloat.split(".");
	var lastChar = splitNumber[1].substr(splitNumber[1].length - 1);
	if(lastChar > 0 && lastChar < 5){
		cNsplitNumber[1]--;
	}
	return Number(splitNumber[0]).toLocaleString('en').concat('.').concat(cNsplitNumber[1]);
  };
});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>

(Math.round((10.2)*100)/100).toFixed(2)

Це має дати: 10.20

(Math.round((.05)*100)/100).toFixed(2)

Це має дати: 0.05

(Math.round((4.04)*100)/100).toFixed(2)

Це має дати: 4.04

тощо.

Це дуже просто і працює так само добре, як і будь-який з інших:

function parseNumber(val, decimalPlaces) {
    if (decimalPlaces == null) decimalPlaces = 0
    var ret = Number(val).toFixed(decimalPlaces)
    return Number(ret)
}

Оскільки toFixed () можна викликати лише на числах, і, на жаль, повертає рядок, це робить весь аналіз для вас в обох напрямках. Ви можете передавати рядок або число, і ви отримуєте номер кожен раз! Виклик parseNumber (1,49) дасть вам 1, а parseNumber (1,49,2) дасть вам 1,50. Так само, як найкращі з них!

Ви також можете скористатися .toPrecision()методом і деяким спеціальним кодом, і завжди округляйте до п’ятої десяткової цифри незалежно від довжини внутрішньої частини.

function glbfrmt (number, decimals, seperator) {
    return typeof number !== 'number' ? number : number.toPrecision( number.toString().split(seperator)[0].length + decimals);
}

Ви також можете зробити плагін для кращого використання.

Просто, як це.

var rounded_value=Math.round(value * 100) / 100;

Я знайшов дуже простий спосіб, який вирішив цю проблему для мене і може бути використаний або адаптований:

td[row].innerHTML = price.toPrecision(price.toFixed(decimals).length

100% працює !!! Спробуй це

<html>
     <head>
      <script>
      function replacePonto(){
        var input = document.getElementById('qtd');
        var ponto = input.value.split('.').length;
        var slash = input.value.split('-').length;
        if (ponto > 2)
                input.value=input.value.substr(0,(input.value.length)-1);

        if(slash > 2)
                input.value=input.value.substr(0,(input.value.length)-1);

        input.value=input.value.replace(/[^0-9.-]/,'');

        if (ponto ==2)
	input.value=input.value.substr(0,(input.value.indexOf('.')+3));

if(input.value == '.')
	input.value = "";
              }
      </script>
      </head>
      <body>
         <input type="text" id="qtd" maxlength="10" style="width:140px" onkeyup="return replacePonto()">
      </body>
    </html>