Форматирование числа с точностью до двух знаков после запятой в JavaScript

Я обычно добавляю это в свою личную библиотеку, и после нескольких предложений, а также используя решение от @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);
}

Это решение справится с исключениями, о которых сообщалось.

Вы можете быстро и легко округлить число до двух десятичных знаков, используя комбинацию методов toFixed и parseFloat. Ниже приведён пример использования этого подхода:

let number = 2.55435930;

let roundedString = number.toFixed(2);    // "2.55"

let twoDecimalsNumber = parseFloat(roundedString);    // 2.55

let directly = parseFloat(number.toFixed(2));    // 2.55

В этом примере метод toFixed(2) форматирует число с двумя десятичными знаками, превращая его в строку. Затем parseFloat преобразует эту строку обратно в число, что позволяет получить округлённое значение. При необходимости вы также можете использовать конструктор parseFloat сразу с toFixed, что упрощает код.

Один из способов гарантировать, что у вас будет число с 2 десятичными знаками:

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

Если это вызывает ошибки округления, вы можете использовать следующий подход, как объяснил Джеймс в своем комментарии:

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

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

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, за которым следуют три 0 справа от десятичной точки. Поэтому это должно быть безопасно использовать.

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

Вот и все. Используйте это с пользой 😉

EDIT: добавлена функциональность для "коррекции" отрицательных чисел.

Метод toFixed(n) задает количество знаков после запятой, в то время как toPrecision(x) определяет общее количество значущих цифр в числе.

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

// Пример: toPrecision(4), когда число имеет 7 цифр (3 до запятой, 4 после)
    // В этом случае, число будет округлено до десятых
    num = 500.2349;
    result = num.toPrecision(4); // result будет равен 500.2

Если же вам нужно зафиксировать число с определенным количеством знаков после запятой, вы можете использовать toFixed:

result = num.toFixed(2); // Это вернет строку "500.23"

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