Полное руководство: Округление чисел до 2 знаков после запятой в JavaScript

Чтобы округлять числа до не более чем 2 знаков после запятой в JavaScript только при необходимости, можно использовать комбинацию toFixed(2) с последующим parseFloat() для автоматического удаления конечных нулей. Этот подход гарантирует, что целые числа останутся целыми, а десятичные дроби будут правильно округлены, а лишние нули удалены.

Содержание

• Использование toFixed() с parseFloat()
• Метод умножения с Math.round()
• API Intl.NumberFormat
• Пользовательские вспомогательные функции
• Обработка крайних случаев и проблем точности
• Полные примеры реализации
• Сравнение методов

Использование toFixed() с parseFloat()

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

function roundToTwoDecimals(num) {
    return parseFloat(num.toFixed(2));
}

// Примеры
console.log(roundToTwoDecimals(10));        // 10
console.log(roundToTwoDecimals(1.7777777)); // 1.78
console.log(roundToTwoDecimals(9.1));       // 9.1

Этот подход работает, потому что toFixed(2) преобразует число в строку ровно с 2 знаками после запятой, а parseFloat() анализирует эту строку обратно в число, автоматически удаляя любые конечные нули после десятичной точки.

Согласно документации метода JavaScript toFixed(), метод toFixed() округляет строку до указанного количества десятичных знаков, что именно то, что нам нужно для начального шага округления.

Метод умножения с Math.round()

Другой подход involves использование Math.round() с умножением и делением для достижения того же результата без преобразования в строку:

function roundToTwoDecimalsMath(num) {
    return Math.round(num * 100) / 100;
}

// Примеры
console.log(roundToTwoDecimalsMath(10));        // 10
console.log(roundToTwoDecimalsMath(1.7777777)); // 1.78
console.log(roundToTwoDecimalsMath(9.1));       // 9.1

Этот метод работает следующим образом:

1. Умножаем число на 100, чтобы сдвинуть десятичную точку на два места вправо
2. Используем Math.round() для округления до ближайшего целого числа
3. Делим на 100, чтобы сдвинуть десятичную точку обратно в исходное положение

Однако, как отмечено в документации Sentry, при использовании этого метода вы можете периодически получать ошибки округления из-за проблем с точностью с плавающей запятой.

API Intl.NumberFormat

Для более сложного форматирования можно использовать API Intl.NumberFormat, который обеспечивает форматирование чисел с учетом локали:

function roundToTwoDecimalsIntl(num) {
    return parseFloat(new Intl.NumberFormat('en-US', {
        minimumFractionDigits: 0,
        maximumFractionDigits: 2
    }).format(num));
}

// Примеры
console.log(roundToTwoDecimalsIntl(10));        // 10
console.log(roundToTwoDecimalsIntl(1.7777777)); // 1.78
console.log(roundToTwoDecimalsIntl(9.1));       // 9.1

Руководство по округлению JavaScript до 2 знаков после запятой объясняет, что API Intl.NumberFormat является универсальным конструктором для форматирования чисел в соответствии с локальными соглашениями.

Пользовательские вспомогательные функции

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

function toOptionalFixed(num, digits = 2) {
    const number = parseFloat(num.toFixed(digits));
    return number;
}

// Примеры
console.log(toOptionalFixed(10));        // 10
console.log(toOptionalFixed(1.7777777)); // 1.78
console.log(toOptionalFixed(9.1));       // 9.1
console.log(toOptionalFixed(1.005));     // 1.01 (обрабатывает проблемы точности)

Как показано в примере 30 seconds of code, этот подход создает повторно используемую функцию, которую можно применять во всем приложении.

Обработка крайних случаев и проблем точности

В JavaScript хорошо известны проблемы точности с плавающей запятой. Например, 1.005 может не округлиться до 1.01 как ожидается из-за двоичного представления:

// Проблемный случай
console.log(Math.round(1.005 * 100) / 100); // 1 вместо 1.01

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

function preciseRound(num, decimals = 2) {
    const factor = Math.pow(10, decimals);
    return Math.round(num * factor + Number.EPSILON) / factor;
}

// Примеры
console.log(preciseRound(1.005)); // 1.01 (правильно обрабатывает точность)
console.log(preciseRound(10));    // 10
console.log(preciseRound(9.1));   // 9.1

В руководстве codeparrot упоминается, что Number.EPSILON учитывает незначительные неточности в вычислениях с плавающей запятой, повышая точность в JavaScript при округлении до 2 знаков после запятой для сложных чисел, таких как 1.005 или 1.255.

Полные примеры реализации

Вот полная реализация с несколькими подходами:

// Метод 1: toFixed() + parseFloat
function roundToTwoMethod1(num) {
    return parseFloat(num.toFixed(2));
}

// Метод 2: Math.round() с умножением
function roundToTwoMethod2(num) {
    return Math.round(num * 100) / 100;
}

// Метод 3: Пользовательская функция с учетом точности
function roundToTwoMethod3(num) {
    const factor = Math.pow(10, 2);
    return Math.round(num * factor + Number.EPSILON) / factor;
}

// Метод 4: Intl.NumberFormat
function roundToTwoMethod4(num) {
    return parseFloat(new Intl.NumberFormat('en-US', {
        minimumFractionDigits: 0,
        maximumFractionDigits: 2
    }).format(num));
}

// Тестирование всех методов
const testNumbers = [10, 1.7777777, 9.1, 1.005, 3.14159, 5.5];

console.log('Входные данные\tМетод1\tМетод2\tМетод3\tМетод4');
console.log('------------\t------\t------\t------\t------');

testNumbers.forEach(num => {
    const m1 = roundToTwoMethod1(num);
    const m2 = roundToTwoMethod2(num);
    const m3 = roundToTwoMethod3(num);
    const m4 = roundToTwoMethod4(num);
    
    console.log(`${num}\t\t${m1}\t${m2}\t${m3}\t${m4}`);
});

Сравнение методов

Для большинства приложений подход toFixed(2) + parseFloat() обеспечивает наилучший баланс простоты и надежности. Однако для финансовых приложений, где точность критически важна, рекомендуется пользовательская функция с учетом точности.

Заключение

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

1. Используйте toFixed(2) + parseFloat() - Это самый простой и надежный метод для большинства случаев использования
2. Реализуйте округление с учетом точности - Добавьте Number.EPSILON для лучшей обработки крайних случаев
3. Учитывайте ваши конкретные потребности - Выбирайте между производительностью, читаемостью и требованиями к точности
4. Тщательно тестируйте - Особенно важно для финансовых или научных приложений

Ключевая идея заключается в том, что вам нужны как логика округления, так и удаление конечных нулей для достижения желаемого поведения форматирования. Метод toFixed() в сочетании с parseFloat() предоставляет эту функциональность в чистом и читаемом виде, который работает для большинства приложений JavaScript.

Источники

1. Метод JavaScript toFixed() - W3Schools
2. Как округлить до не более чем двух знаков после запятой в JavaScript - Sentry
3. Округление JavaScript до 2 знаков после запятой: Полное руководство - CodeParrot
4. Как округлить число до двух знаков после запятой в JavaScript - CoreUI
5. Округление до 2 знаков после запятой в JavaScript (с кодом) - FavTutor
6. Как округлить до 2 знаков после запятой в JavaScript - Medium
7. Число в фиксированную точку без конечных нулей - 30 seconds of code
8. Удаление конечных нулей из числа в JavaScript - BobbyHadz