Как отформатировать float в javascript?

есть функции для округления чисел. Например:

var x = 5.0364342423;
print(x.toFixed(2));

печать 5.04.

EDIT: Скрипка

будьте осторожны при использовании toFixed():

во-первых, округление числа выполняется с использованием двоичного представления числа, что может привести к неожиданному поведению. Например

(0.595).toFixed(2) === '0.59'

вместо '0.6'.

во-вторых, есть ошибка IE с toFixed(). В IE (по крайней мере, до версии 7, не проверял IE8) выполняется следующее:

(0.9).toFixed(0) === '0'

это может быть хорошей идеей, чтобы следовать предложению kkyy или использовать специальный , например,

function toFixed(value, precision) {
    var power = Math.pow(10, precision || 0);
    return String(Math.round(value * power) / power);
}

еще одна проблема, чтобы быть в курсе, это toFixed() может производить ненужные нули в конце числа. Например:

var x=(23-7.37)
x
15.629999999999999
x.toFixed(6)
"15.630000"

идея в том, чтобы очистить выход с помощью RegExp:

function humanize(x){
  return x.toFixed(6).replace(/\.?0*$/,'');
}

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

humanize(23-7.37)
"15.63"
humanize(1200)
"1200"
humanize(1200.03)
"1200.03"
humanize(3/4)
"0.75"
humanize(4/3)
"1.333333"

var x = 0.3445434
x = Math.round (x*100) / 100 // this will make nice rounding

этот вопрос, вероятно, стоит еще один ответ: Как упоминалось Дони и ArteQ, округление зависит от потери точности (то есть 0.5 может стать 0.49999...). Следствием этого является то, что округление не является ни половину, ни половина, ни любой другой последовательный метод округления, и даст противоречивый результат независимо от метода, который вы используете.

действительно toFixed влияет также:

(0.335).toFixed(2) == 0.34
(0.345).toFixed(2) == 0.34

Итак, какой бы метод вы используете, если вам нужна последовательность в округлении вам лучше добавить (или удалить) Эпсилон.

например.для половины округления с помощью toFixed:

var epsilon = 0.001;
(0.335 + epsilon).toFixed(2) == 0.34;
(0.345 + epsilon).toFixed(2) == 0.35;

это то же самое, если вы создаете свою собственную функцию, добавьте/удалите Эпсилон перед вычислением.

обновление :

как указал Матиас, этот метод имеет недостаток: независимо от значения Эпсилона, 0.334999999... всегда будет округляться на 0.34 вместо 0.35. Поэтому у нас есть последовательность, но нет "стандартное округление".

существует проблема со всеми этими решениями, плавающими вокруг с использованием множителей. К сожалению, решения kkyy и Кристофа неверны.

пожалуйста, проверьте ваш код для числа 551.175 С 2 десятичными знаками-он будет округляться до 551.17 в то время как это должно быть 551.18 ! Но если вы проверяете для ex. 451.175 это будет ОК-451.18. Так что это трудно обнаружить эту ошибку на первый взгляд.

проблема с умножением: попробовать 551.175 * 100 = 55117.49999999999 (ups!)

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

function roundFix(number, precision)
{
    var multi = Math.pow(10, precision);
    return Math.round( (number * multi).toFixed(precision + 1) ) / multi;
}

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

function roundOf(n, p) {
    const n1 = n * Math.pow(10, p + 1);
    const n2 = Math.floor(n1 / 10);
    if (n1 >= (n2 * 10 + 5)) {
        return (n2 + 1) / Math.pow(10, p);
    }
    return n2 / Math.pow(10, p);
}

// All edge cases listed in this thread
roundOf(95.345, 2); // 95.35
roundOf(95.344, 2); // 95.34
roundOf(5.0364342423, 2); // 5.04
roundOf(0.595, 2); // 0.60
roundOf(0.335, 2); // 0.34
roundOf(0.345, 2); // 0.35
roundOf(551.175, 2); // 551.18
roundOf(0.3445434, 2); // 0.34

теперь вы можете безопасно форматировать это значение с помощью toFixed (p). Так что с вашим конкретным случаем:

roundOf(0.3445434, 2).toFixed(2); // 0.34

function trimNumber(num, len) {
  const modulu_one = 1;
  const start_numbers_float=2;
  var int_part = Math.trunc(num);
  var float_part = String(num % modulu_one);
      float_part = float_part.slice(start_numbers_float, start_numbers_float+len);
  return int_part+'.'+float_part;
}

возможно, вы также хотите, десятичный разделитель? Вот функция, которую я только что сделал:

function formatFloat(num,casasDec,sepDecimal,sepMilhar) {
    if (num < 0)
    {
        num = -num;
        sinal = -1;
    } else
        sinal = 1;
    var resposta = "";
    var part = "";
    if (num != Math.floor(num)) // decimal values present
    {
        part = Math.round((num-Math.floor(num))*Math.pow(10,casasDec)).toString(); // transforms decimal part into integer (rounded)
        while (part.length < casasDec)
            part = '0'+part;
        if (casasDec > 0)
        {
            resposta = sepDecimal+part;
            num = Math.floor(num);
        } else
            num = Math.round(num);
    } // end of decimal part
    while (num > 0) // integer part
    {
        part = (num - Math.floor(num/1000)*1000).toString(); // part = three less significant digits
        num = Math.floor(num/1000);
        if (num > 0)
            while (part.length < 3) // 123.023.123  if sepMilhar = '.'
                part = '0'+part; // 023
        resposta = part+resposta;
        if (num > 0)
            resposta = sepMilhar+resposta;
    }
    if (sinal < 0)
        resposta = '-'+resposta;
    return resposta;
}

невозможно избежать несогласованного округления цен с x. xx5 в качестве фактического значения, используя либо умножение, либо деление. Если вам нужно рассчитать правильные цены на стороне клиента, вы должны сохранить все суммы в центах. Это связано с природой внутреннего представления числовых значений в JavaScript. Обратите внимание, что Excel страдает от тех же проблем, поэтому большинство людей не заметят небольшие ошибки, вызванные этим явлением. Однако ошибки могут накапливаться всякий раз, когда вы добавляете много вычисленные значения, есть целая теория вокруг этого, включающая порядок вычислений и другие методы, чтобы минимизировать ошибку в конечном результате. Чтобы подчеркнуть проблемы с десятичными значениями, обратите внимание, что 0.1 + 0.2 не совсем равно 0.3 в JavaScript, а 1 + 2 равно 3.

/** don't spend 5 minutes, use my code **/
function prettyFloat(x,nbDec) { 
    if (!nbDec) nbDec = 100;
    var a = Math.abs(x);
    var e = Math.floor(a);
    var d = Math.round((a-e)*nbDec); if (d == nbDec) { d=0; e++; }
    var signStr = (x<0) ? "-" : " ";
    var decStr = d.toString(); var tmp = 10; while(tmp<nbDec && d*tmp < nbDec) {decStr = "0"+decStr; tmp*=10;}
    var eStr = e.toString();
    return signStr+eStr+"."+decStr;
}

prettyFloat(0);      //  "0.00"
prettyFloat(-1);     // "-1.00"
prettyFloat(-0.999); // "-1.00"
prettyFloat(0.5);    //  "0.50"

Я использую этот код для форматирования поплавков. Он основан на toPrecision() но это лишает ненужных нулей. Я жду предложений, как упростить выражение.

function round(x, n) {
    var exp = Math.pow(10, n);
    return Math.floor(x*exp + 0.5)/exp;
}

пример использования:

function test(x, n, d) {
    var rounded = rnd(x, d);
    var result = rounded.toPrecision(n);
    result = result.replace(/\.?0*$/, '');
    result = result.replace(/\.?0*e/, 'e');
    result = result.replace('e+', 'e');
    return result;  
}

document.write(test(1.2000e45, 3, 2) + '=' + '1.2e45' + '<br>');
document.write(test(1.2000e+45, 3, 2) + '=' + '1.2e45' + '<br>');
document.write(test(1.2340e45, 3, 2) + '=' + '1.23e45' + '<br>');
document.write(test(1.2350e45, 3, 2) + '=' + '1.24e45' + '<br>');
document.write(test(1.0000, 3, 2) + '=' + '1' + '<br>');
document.write(test(1.0100, 3, 2) + '=' + '1.01' + '<br>');
document.write(test(1.2340, 4, 2) + '=' + '1.23' + '<br>');
document.write(test(1.2350, 4, 2) + '=' + '1.24' + '<br>');

    You can try this if you want don't want to use rounding

 function myFunction() {
            var str = 12.234556; 
            str = str.toString().split('.');
            var res = str[1].slice(0, 2);
            document.getElementById("demo").innerHTML = str[0]+'.'+res;
        }
output:12.23

str.toString().split('.') преобразует вещественное число в строку, потом разбить его на '.-

результирующие переменные будут массив с двумя строковыми элементами типа, первый элемент будет 12 и второй элемент будет 234556

str[1].slice(0, 2) будет нарезать вашу вторую (234556) строку в первые два символа, который является 23

затем просто конкатенация первой и результирующей строки через str[0]+'.'+res

надеюсь, это поможет