Номер формата, который должен всегда показывать 2 десятичных знака

Я хотел бы отформатировать мои номера, чтобы всегда показывать 2 десятичных знака, округляя, где это применимо.

Примеры:

number     display
------     -------
1          1.00
1.341      1.34
1.345      1.35

Я использовал это:

parseFloat(num).toFixed(2);

Но он отображает 1 как 1, а не 1.00.

Ответ 1

Это отлично работает в FF4:

parseFloat(Math.round(num3 * 100) / 100).toFixed(2);

Демо-версия

var num1 = "1";
document.getElementById('num1').innerHTML = parseFloat(Math.round(num1 * 100) / 100).toFixed(2);

var num2 = "1.341";
document.getElementById('num2').innerHTML = parseFloat(Math.round(num2 * 100) / 100).toFixed(2);

var num3 = "1.345";
document.getElementById('num3').innerHTML = parseFloat(Math.round(num3 * 100) / 100).toFixed(2);

span {
    border: 1px solid #000;
    margin: 5px;
    padding: 5px;
}

<span id="num1"></span>
<span id="num2"></span>
<span id="num3"></span>

Ответ 2

Number(1).toFixed(2);         // 1.00
Number(1.341).toFixed(2);     // 1.34
Number(1.345).toFixed(2);     // 1.34 NOTE: See andy comment below.
Number(1.3450001).toFixed(2); // 1.35

document.getElementById('line1').innerHTML = Number(1).toFixed(2);
document.getElementById('line2').innerHTML = Number(1.341).toFixed(2);
document.getElementById('line3').innerHTML = Number(1.345).toFixed(2);
document.getElementById('line4').innerHTML = Number(1.3450001).toFixed(2);

<span id="line1"></span>
<br/>
<span id="line2"></span>
<br/>
<span id="line3"></span>
<br/>
<span id="line4"></span>

Ответ 3

Этот ответ потерпит неудачу, если value = 1.005.

В качестве лучшего решения можно избежать проблемы округления, используя числа, представленные в экспоненциальной записи:

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

Более чистый код, предложенный @Kon и первоначальным автором:

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces)

Вы можете добавить toFixed() в конце, чтобы сохранить десятичную точку, например: 1.00, но учтите, что он вернется в виде строки.

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces).toFixed(decimalPlaces)

Кредит: округление десятичных дробей в JavaScript

Ответ 4

var num = new Number(14.12);
console.log(num.toPrecision(2));//outputs 14
console.log(num.toPrecision(3));//outputs 14.1
console.log(num.toPrecision(4));//outputs 14.12
console.log(num.toPrecision(5));//outputs 14.120

Ответ 5

Гораздо более общее решение для округления до N мест

function roundN(num,n){
  return parseFloat(Math.round(num * Math.pow(10, n)) /Math.pow(10,n)).toFixed(n);
}


console.log(roundN(1,2))
console.log(roundN(1.34,2))
console.log(roundN(1.35,2))
console.log(roundN(1.344,2))
console.log(roundN(1.345,2))
console.log(roundN(1.344,3))
console.log(roundN(1.345,3))
console.log(roundN(1.3444,3))
console.log(roundN(1.3455,3))

Output

1.00
1.34
1.35
1.34
1.35
1.344
1.345
1.344
1.346

Ответ 6

Самый простой ответ:

var num = 1.2353453;
num.toFixed(2); // 1.24

Пример: http://jsfiddle.net/E2XU7/

Ответ 7

Для наиболее точного округления создайте эту функцию:

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

и используйте его для округления до двух знаков после запятой:

console.log("seeked to " + round(1.005, 2));
> 1.01

Спасибо Razu, эта статья, и ссылка MDN Math.round.

Ответ 8

Если вы уже используете jQuery, вы можете использовать плагин jQuery Number Format.

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

$.number( 123, 2 ); // Returns '123.00'

Вы также можете получить jQuery Number Format из GitHub.

Ответ 9

var number = 123456.789;


console.log(new Intl.NumberFormat('en-IN', { maximumFractionDigits: 2 }).format(number));

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat

Ответ 10

Это то, что вы имеете в виду?

function showAsFloat(num, n){
      return !isNaN(+num) ? (+num).toFixed(n || 2) : num;
}

document.querySelector('#result').textContent = 
    [
     'command                      | result',
     '-----------------------------------------------',
     'showAsFloat(1);              | ' + showAsFloat(1),
     'showAsFloat(1.314);          | ' + showAsFloat(1.314),
     'showAsFloat(\'notanumber\')    | ' + showAsFloat('notanumber'),
     'showAsFloat(\'23.44567\', 3)   | ' + showAsFloat('23.44567', 3),
     'showAsFloat(2456198, 5)      | ' + showAsFloat('2456198', 5),
     'showAsFloat(0);              | ' + showAsFloat(0)
    ].join('\n');

<pre id="result"></pre>

Ответ 11

Преобразуйте число в строку, сохраняя только два десятичных знака:

var num = 5.56789;
var n = num.toFixed(2);

Результат n будет:

5.57

Ответ 12

Вы ищете пол?

var num = 1.42482;
var num2 = 1;
var fnum = Math.floor(num).toFixed(2);
var fnum2 = Math.floor(num2).toFixed(2);
alert(fnum + " and " + fnum2); //both values will be 1.00

Ответ 13

Если требуется конкретное форматирование, вы должны написать свою собственную процедуру или использовать библиотечную функцию, которая делает то, что вам нужно. Основная функциональность ECMAScript обычно недостаточна для отображения отформатированных чисел.

~~Подробное объяснение округления и форматирования можно найти здесь: http://www.merlyn.demon.co.uk/js-round.htm#RiJ~~

Как правило, округление и форматирование должны быть определены только как последний шаг перед выходом. Это может привести к неожиданным большим ошибкам и уничтожению форматирования.

Ответ 14

function currencyFormat (num) {
    return "$" + num.toFixed(2).replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1,")
}

console.info(currencyFormat(2665));   // $2,665.00
console.info(currencyFormat(102665)); // $102,665.00

Ответ 15

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

function numberFormat(val, decimalPlaces) {

    var multiplier = Math.pow(10, decimalPlaces);
    return (Math.round(val * multiplier) / multiplier).toFixed(decimalPlaces);
}

Ответ 16

Для современных браузеров используйте toLocaleString:

var num = 1.345;
num.toLocaleString(undefined, { maximumFractionDigits: 2, minimumFractionDigits: 2 });

Укажите тег локали в качестве первого параметра для управления десятичным разделителем. Для точки используйте, например, английский язык США:

num.toLocaleString("en-US", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

который дает:

1,35

В большинстве стран Европы в качестве десятичного разделителя используется запятая, поэтому, если вы, например, используете язык Швеции/Швеции:

num.toLocaleString("sv-SE", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

это даст:

1.35

Ответ 17

function number_format(string,decimals=2,decimal=',',thousands='.',pre='R$ ',pos=' Reais'){
  var numbers = string.toString().match(/\d+/g).join([]);
  numbers = numbers.padStart(decimals+1, "0");
  var splitNumbers = numbers.split("").reverse();
  var mask = '';
  splitNumbers.forEach(function(d,i){
    if (i == decimals) { mask = decimal + mask; }
    if (i>(decimals+1) && ((i-2)%(decimals+1))==0) { mask = thousands + mask; }
    mask = d + mask;
  });
  return pre + mask + pos;
}
var element = document.getElementById("format");
var money= number_format("10987654321",2,',','.');
element.innerHTML = money;

#format{
display:inline-block;
padding:10px;
border:1px solid #ddd;
background:#f5f5f5;
}

<div id='format'>Test 123456789</div>

Ответ 18

Вы не даете нам всей картины.

javascript:alert(parseFloat(1).toFixed(2)) показывает 1,00 в моих браузерах, когда я вставляю его в строку местоположения. Однако, если после этого вы что-то сделаете, он вернется.

var num = 2
document.getElementById('spanId').innerHTML=(parseFloat(num).toFixed(2)-1)


shows 1 and not 1.00

Ответ 19

var quantity = 12;

var import1 = 12.55;

var total = quantity * import1;

var answer = parseFloat(total).toFixed(2);

document.write(answer);

Ответ 20

Мне пришлось выбирать между преобразованиями parseFloat() и Number(), прежде чем я смог сделать toFixed() вызов. Здесь приведен пример форматирования номера после ввода пользовательского ввода.

HTML:

<input type="number" class="dec-number" min="0" step="0.01" />

Обработчик события:

$('.dec-number').on('change', function () {
     const value = $(this).val();
     $(this).val(value.toFixed(2));
});

Вышеприведенный код приведет к исключению TypeError. Обратите внимание, что хотя тип ввода html является "числом", пользовательский ввод фактически является "строковым" типом данных. Однако функция toFixed() может быть вызвана только для объекта, который является Number.

Мой последний код выглядел бы следующим образом:

$('.dec-number').on('change', function () {
     const value = Number($(this).val());
     $(this).val(value.toFixed(2));
});

Причина, по которой я предпочитаю использовать метод Number() vs. parseFloat(), заключается в том, что мне не нужно выполнять дополнительную проверку ни для пустой входной строки, ни для значения NaN. Функция Number() автоматически обрабатывает пустую строку и скрывает ее до нуля.

Ответ 21

Просто наткнитесь на этот самый длинный поток, ниже мое решение:

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

Дайте мне знать, если кто-нибудь может проткнуть дыру

Ответ 22

Мне нравится:

var num = 12.749;
parseFloat((Math.round(num * 100) / 100).toFixed(2)); // 123.75

Обозначьте число с двумя десятичными знаками, затем обязательно проанализируйте его с помощью parseFloat() чтобы возвращать Number, а не String, если вам не все равно, является ли это строкой или номером.

Ответ 23

Расширить Math объект с помощью метода точность

Object.defineProperty(Math, 'precision',{
   value: function (value,precision,type){
             var v = parseFloat(value),
                 p = Math.max(precision,0)||0,
                 t = type||'round';
              return (Math[t](v*Math.pow(10,p))/Math.pow(10,p)).toFixed(p);
          }
    });

console.log(
    Math.precision(3.1,3), // round 3 digits 
    Math.precision(0.12345,2,'ceil'), // ceil 2 digits
    Math.precision(1.1) // integer part
)

Ответ 24

parseInt(number * 100)/100; работал на меня.

Ответ 25

Вот еще одно решение для округления только с использованием минимального значения, то есть убедитесь, что рассчитанная сумма не будет больше исходной суммы (иногда необходимой для транзакций):

Math.floor(num* 100 )/100;

Ответ 26

function numberWithCommas (number) {

var newval = parseFloat(Math.round(number * 100) / 100).toFixed(2);

return newval.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");

}

Ответ 27

Вы можете попробовать этот код:

    function FormatNumber(number, numberOfDigits = 2) {
        try {
            return new Intl.NumberFormat('en-US').format(parseFloat(number).toFixed(2));
        } catch (error) {
            return 0;
        }
    }

    var test1 = FormatNumber('1000000.4444');
    alert(test1); // 1,000,000.44

    var test2 = FormatNumber(100000000000.55555555, 4);
    alert(test2); // 100,000,000,000.56

Ответ 28

(num + "").replace(/^([0-9]*)(\.[0-9]{1,2})?.*$/,"$1$2")

Ответ 29

Вот как я решаю свою проблему:

parseFloat(parseFloat(floatString).toFixed(2));