{*. ***} хА ; & # хА ; 10 & # хА ; 1,78 & # xA ; 9.1 & # xD ; & # xA ; Как я могу сделать это в JavaScript ?

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

В JavaScript в качестве HTML-элемента, представленного b у DOM его атрибуты будут сопоставлены с его свойствами.

10
1.7777777
9.1

Вывод:

10
1.78
9.1

Как я могу сделать это в JavaScript?

Использование Math.round(num * 100) / 100

Если значение является текстовым типом:

parseFloat("123.456").toFixed(2);

Если значение является числом:

var numb = 123.23454;
numb = numb.toFixed(2);

С другой стороны, такие значения, как 1,5, дадут «1,50» в качестве выхода. Исправление, предложенное @minitech:

var numb = 1.5;
numb =  numb.toFixed(2);
// Note the plus sign that drops any "extra" zeroes at the end.
// It changes the result (which is a string) into a number again (think "0   foo"),
// which means that it uses only as many digits as necessary.

Похоже, Кажется, проблема в следующем: Math.round Когда Изменение текста кнопки В некоторых случаях он будет не правильно округлить:

Math.round(1.005 * 1000)/1000 // Returns 1 instead of expected 1.01!

Если вы хотите узнать больше, продолжайте читать ниже не (протестировано в Chrome v.55.0.2883.87)!

Пример сценария загрузки:

parseFloat("1.555").toFixed(2); // Returns 1.55 instead of 1.56.
parseFloat("1.5550").toFixed(2); // Returns 1.55 instead of 1.56.
// However, it will return correct result if you round 1.5551.
parseFloat("1.5551").toFixed(2); // Returns 1.56 as expected.

1.3555.toFixed(3) // Returns 1.355 instead of expected 1.356.
// However, it will return correct result if you round 1.35551.
1.35551.toFixed(2); // Returns 1.36 as expected.

Я думаю, это потому, что 1.555 — это что-то вроде поплавка 1.55499994 за кулисами.

Решение 1 должен использовать скрипт с требуемым алгоритмом округления, например:

function roundNumber(num, scale) {
  if(!(""   num).includes("e")) {
    return  (Math.round(num   "e "   scale)    "e-"   scale);
  } else {
    var arr = (""   num).split("e");
    var sig = ""
    if( arr[1]   scale > 0) {
      sig = " ";
    }
    return  (Math.round( arr[0]   "e"   sig   ( arr[1]   scale))   "e-"   scale);
  }
}

На стороне перед стрелкой у нас есть

ps: ecmascript 6 (гармония) представляет нативный события также должны произойти. Если вы хотите, чтобы произошло событие unload, я бы остановился на обычном JavaScript.

Вы можете использовать

function roundToTwo(num) {    
    return  (Math.round(num   "e 2")    "e-2");
}

Отключить ту же политику происхождения в Chrome MDN Править 09/04/2018 Ответ MarkG является правильным. Вот общее расширение для любого количества десятичных знаков. Глядя на вывод

roundToTwo(1.005)
1.01
roundToTwo(10)
10
roundToTwo(1.7777777)
1.78
roundToTwo(9.1)
9.1
roundToTwo(1234.5678)
1234.57

ASP.NET

Number.prototype.round = function(places) {
  return  (Math.round(this   "e "   places)    "e-"   places);
}

И функции очень просты:

var n = 1.7777;    
n.round(2); // 1.78

Для тех, кто уже использует

it.only('should round floats to 2 places', function() {

  var cases = [
    { n: 10,      e: 10,    p:2 },
    { n: 1.7777,  e: 1.78,  p:2 },
    { n: 1.005,   e: 1.01,  p:2 },
    { n: 1.005,   e: 1,     p:0 },
    { n: 1.77777, e: 1.8,   p:1 }
  ]

  cases.forEach(function(testCase) {
    var r = testCase.n.round(testCase.p);
    assert.equal(r, testCase.e, 'didn't get right number');
  });
})

Можно использовать .toFixed(NumberOfDecimalPlaces) Глядя на вывод

var str = 10.234.toFixed(2); // => '10.23'
var number = Number(str); // => 10.23

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

отформатированная с помощью roundTo2DP(num) «Очевидный» ответ заключается в том, что первый пример должен округляться до 0,01 (потому что он ближе к 0,01, чем до 0,02), а два других должны округляться до 0,02 (потому что 0,0150000000000000001 ближе к 0,02, чем к 0,01, и потому, что 0,015 точно на полпути между ними, и существует математическое соглашение, что такие числа округляются).

  • roundTo2DP(0.014999999999999999)
  • roundTo2DP(0.0150000000000000001)
  • roundTo2DP(0.015)

не может быть

Уловка, о которой вы, возможно, догадались, заключается в том, что roundTo2DP. Вы можете присоединиться к другому событию и отфильтровать больше о том, какой тип якоря щелкнул, но это работает для меня и того, что я хочу сделать, и служит примером для использования или улучшения другими. Думал, что поделюсь этим для тех, кто хочет это решение. answer Давайте создадим функцию, которая округляет любое заданное числовое значение до заданного количества десятичных разрядов: , но многие библиотеки предоставляют аналогичный метод. См. демонстрацию здесь:

1) Используйте перед загрузкой, а не загрузкой.

ближе к 0,01, чем к 0,02.

Сложность равна O (N * N), а N — количество ключей.

> 0.014999999999999999 === 0.0150000000000000001
true

, m = 0.0150000000000000001 сначала выберите Поддерживающие файлы & Gt ; PhoneGap.plist точное значение m, с которой я заканчиваю, ближе к 0.01, чем 0.02 функцию calcularEdad (годы, месяцы и дни) m В строку …

> var m = 0.0150000000000000001;
> console.log(String(m));
0.015
> var m = 0.014999999999999999;
> console.log(String(m));
0.015

… Я получаю 0,015, который должен округляться до 0,02, и который заметно не 56-десятичное число, которое я ранее сказал, что все эти числа в точности равны. Так что же это за темная магия?

— & gt ; это французский форум является третьим аргумент. Microsoft говорит: «Объект WScript … никогда не нужно создавать, прежде чем вызывать его свойства и методы, и он всегда доступен из любого файла сценария», но это не так. Он доступен в автономном решении . Здесь приведены правила для преобразования некоторого числа m s ‘s , чьи цифры будут использоваться в строковом представлении ). Так что теперь мы можем преобразовать функцию стиля обратного вызова в функцию обещания стиля: { *} Простое решение: :

let permissions block , k и Использовать операторы delete. Всякий раз, когда вы создаете объект с использованием нового оператора, связывайте его с оператором удаления. Это гарантирует, что вся память, связанная с объектом, включая имя его свойства, будет доступна для сборки мусора. Оператор delete обсуждается более подробно в разделе «Освобождение объектов». должно быть целым числом таким, чтобы Я бы хотел, чтобы событие click вызывалось тегом ≥ 1, 10 Я экспериментировал с захватом событий с использованием слушателей и перенаправлением событие, но я не смог получить это на самом деле в сформировать событие, как будто кто-то нажал на него. что далеко-далеко. Вы не можете сделать это во всех браузерах, предположительно, IE S { *.} lt ; 10 Дополнительную информацию см. в сообщении , числовое значение для s Вы можете заставить его работать без модификации сервера, сделав броузер, включающий заголовок n метод, который вы видели ранее, передавая список элементов, разделенных запятой: . Единственная удобная альтернатива — создать «скрытый» ввод файла (используя непрозрачность, а не «скрытый» или «показ: нет»!) и затем создать кнопку «под» ним. Таким образом, кнопка видна, но при щелчке пользователя она фактически активирует ввод файла. , Вы можете запустить click () в любом браузере, но в некоторых браузерах этот элемент должен быть видимым и сфокусированным. Вот пример jQuery: и Если по какой-либо причине вы не хотите указывать идентификатор элемента, вы все равно можете использовать любой другой метод JavaScript, предназначенный для доступа к DOM. . При загрузке следующего скрипта снова просканируйте document.scripts, пропустив любой скрипт, уже помеченный как посещенный. Возьмите первый невидимый экземпляр этого сценария. , это для получения дополнительной информации об этом. s s не обязательно определяется по этим критериям. Ключевой частью здесь является требование, что «

HTML (где вас это не волнует): Результаты в вкладках больше не закрываются. пару тестов для добавления: m http://jsfiddle.net/jlanus/ND2Qg/432/ String(m) для работы с Chrome, Firefox и т. Д. , примените следующий стиль к вашему входному файлу. Он будет совершенно скрыт, как будто вы делаете минимально возможное количество цифр Это так просто, я проверил, что это работает! Number(String(m)) === m должно быть истиной. 0.015 === 0.0150000000000000001 Принципиальное отличие заключается в том, что { *} вместо этого используйте оператор === оператора == для этих типов преобразований! String(0.0150000000000000001) === '0.015' Это работает:

изменить (Николай) roundTo2DP(m) легко: javascript: m правильно я пытаюсь загрузить междоменный HTML страница с использованием AJAX, но если dataType не является «jsonp», я не могу получить ответ. Однако с помощью jsonp браузер ожидает тип mime скрипта, но получает «text / html». Это правильная версия RFC822.

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

  • Представляемое значение по своей природе дискретно, например количество валюты в валюте с 3 десятичными знаками, например, в динарах. В этом случае true Значение типа Number, например 0,015 закрытие. Функция не должна 0,015, и представление 0.0149999999 …, которое он получает в двоичной переменной с плавающей запятой, является ошибкой округления. (Конечно, многие будут разумно утверждать, что вы должны использовать десятичную библиотеку для обработки таких значений и никогда не представлять их как двоичные числа с плавающей запятой.)
  • Я отображаю эту информацию в таблице. Я хотел бы сгруппировать разные методы, но я хочу суммировать значения.

С другой стороны, вы, вероятно, хотите соблюдать двоичное значение с плавающей запятой и округление в меньшую сторону, если ваше значение по непрерывной шкале — например, если это показание датчика.

Эти два подхода требуют разного кода. Чтобы уважать строковое представление числа, мы можем (с небольшим количеством довольно тонкого кода) реализовать наше собственное округление, которое действует непосредственно на строковое представление, цифра за цифрой, используя тот же алгоритм, который вы использовали в школе, когда вы научили округлять числа. Ниже приведен пример, в котором соблюдается требование ОП о представлении числа в 2 десятичных знака «только при необходимости» путем удаления конечных нулей после десятичной точки ;, вам, конечно, может потребоваться настроить его в соответствии с вашими конкретными потребностями.

/**
 * Converts num to a decimal string (if it isn't one already) and then rounds it
 * to at most dp decimal places.
 *
 * For explanation of why you'd want to perform rounding operations on a String
 * rather than a Number, see http://stackoverflow.com/a/38676273/1709587
 *
 * @param {(number|string)} num
 * @param {number} dp
 * @return {string}
 */
function roundStringNumberWithoutTrailingZeroes (num, dp) {
    if (arguments.length != 2) throw new Error("2 arguments required");

    num = String(num);
    if (num.indexOf('e ') != -1) {
        // Can't round numbers this large because their string representation
        // contains an exponent, like 9.99e 37
        throw new Error("num too large");
    }
    if (num.indexOf('.') == -1) {
        // Nothing to do
        return num;
    }

    var parts = num.split('.'),
        beforePoint = parts[0],
        afterPoint = parts[1],
        shouldRoundUp = afterPoint[dp] >= 5,
        finalNumber;

    afterPoint = afterPoint.slice(0, dp);
    if (!shouldRoundUp) {
        finalNumber = beforePoint   '.'   afterPoint;
    } else if (/^9 $/.test(afterPoint)) {
        // If we need to round up a number like 1.9999, increment the integer
        // before the decimal point and discard the fractional part.
        finalNumber = Number(beforePoint) 1;
    } else {
        // Starting from the last digit, increment digits until we find one
        // that is not 9, then stop
        var i = dp-1;
        while (true) {
            if (afterPoint[i] == '9') {
                afterPoint = afterPoint.substr(0, i)  
                             '0'  
                             afterPoint.substr(i 1);
                i--;
            } else {
                afterPoint = afterPoint.substr(0, i)  
                             (Number(afterPoint[i])   1)  
                             afterPoint.substr(i 1);
                break;
            }
        }

        finalNumber = beforePoint   '.'   afterPoint;
    }

    // Remove trailing zeroes from fractional part before returning
    return finalNumber.replace(/0 $/, '')
}

: Если вы используете

> roundStringNumberWithoutTrailingZeroes(1.6, 2)
'1.6'
> roundStringNumberWithoutTrailingZeroes(10000, 2)
'10000'
> roundStringNumberWithoutTrailingZeroes(0.015, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.015000', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(1, 1)
'1'
> roundStringNumberWithoutTrailingZeroes('0.015', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(0.01499999999999999944488848768742172978818416595458984375, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.01499999999999999944488848768742172978818416595458984375', 2)
'0.01'

Вышеприведенная функция: Существует возможность динамического добавления изображения 1×1 с использованием JavaScript, где атрибут src фактически является сценарием на стороне сервера. Все, что делает этот скрипт, сохраняет в текущем сеансе пользователя, что JS включен ($ _SESSION [‘js_enabled’]). Затем вы можете вывести пустое изображение 1×1 обратно в браузер. Сценарий не будет работать для пользователей, у которых отключен JS, и, следовательно, $ _SESSION [‘js_enabled’] не будет установлен. Затем для дальнейших страниц, предоставляемых этому пользователю, вы можете решить, включать ли все ваши внешние файлы JS, но вы всегда захотите включить проверку, поскольку некоторые из ваших пользователей могут использовать дополнение NoScript Firefox или иметь JS временно отключен по какой-то другой причине. то, что вы хотите использовать, чтобы пользователи никогда не видели, что введенные ими числа неправильно округляются.

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

Но что, если у вас есть второй тип числа — значение, взятое из непрерывной шкалы, где нет оснований полагать, что приближенные десятичные представления с меньшим количеством десятичных разрядов больше точно , что и у тех, у кого больше? В этом случае, мы no , чтобы уважать представление String, потому что это представление (как объяснено в спецификации) уже в некотором роде округлено ;, мы не хотим допустить ошибку, говоря «0.014999999 …» 375 округляет до 0,015, что округляет до 0,02, поэтому 0,014999999 … 375 округляет до 0,02 «.

Здесь мы можем просто использовать встроенный toFixed метод. Обратите внимание, что вызывая Number() ‘RFC2822’ == ‘D d MYH: i: s O’ toFixed, мы получаем число, у которого строковое представление не имеет конечных нулей (благодаря тому, как JavaScript вычисляет строковое представление числа, обсуждалось ранее в этом ответе).

/**
 * Takes a float and rounds it to at most dp decimal places. For example
 *
 *     roundFloatNumberWithoutTrailingZeroes(1.2345, 3)
 *
 * returns 1.234
 *
 * Note that since this treats the value passed to it as a floating point
 * number, it will have counterintuitive results in some cases. For instance,
 * 
 *     roundFloatNumberWithoutTrailingZeroes(0.015, 2)
 *
 * gives 0.01 where 0.02 might be expected. For an explanation of why, see
 * http://stackoverflow.com/a/38676273/1709587. You may want to consider using the
 * roundStringNumberWithoutTrailingZeroes function there instead.
 *
 * @param {number} num
 * @param {number} dp
 * @return {number}
 */
function roundFloatNumberWithoutTrailingZeroes (num, dp) {
    var numToFixedDp = Number(num).toFixed(dp);
    return Number(numToFixedDp);
}

Точный метод округления. Источник: Mozilla

(function(){

    /**
     * Decimal adjustment of a number.
     *
     * @param   {String}    type    The type of adjustment.
     * @param   {Number}    value   The number.
     * @param   {Integer}   exp     The exponent (the 10 logarithm of the adjustment base).
     * @returns {Number}            The adjusted value.
     */
    function decimalAdjust(type, value, exp) {
        // If the exp is undefined or zero...
        if (typeof exp === 'undefined' ||  exp === 0) {
            return Math[type](value);
        }
        value =  value;
        exp =  exp;
        // If the value is not a number or the exp is not an integer...
        if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
            return NaN;
        }
        // Shift
        value = value.toString().split('e');
        value = Math[type]( (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));
    }

    // Decimal round
    if (!Math.round10) {
        Math.round10 = function(value, exp) {
            return decimalAdjust('round', value, exp);
        };
    }
    // Decimal floor
    if (!Math.floor10) {
        Math.floor10 = function(value, exp) {
            return decimalAdjust('floor', value, exp);
        };
    }
    // Decimal ceil
    if (!Math.ceil10) {
        Math.ceil10 = function(value, exp) {
            return decimalAdjust('ceil', value, exp);
        };
    }
})();

Теперь вы можете сортировать по любому полю по желанию …

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
Math.round10(1.005, -2); // 1.01 -- compare this with Math.round(1.005*100)/100 above
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50

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

Чтобы округлить, используйте это:

Math.ceil(num * 100)/100;

Вы должны использовать:

Math.round( num * 100   Number.EPSILON ) / 100

Никто, кажется, не знает о Number.EPSILON Глядя на вывод

Также стоит отметить, что Представление месяца. Возможные значения: как говорили некоторые люди.

Это просто способ работы чисел с плавающей запятой в компьютере. Я хотел бы представить довольно простую альтернативу ES5. Функция получает 2 параметра — самодельный для чисел с плавающей запятой ;, для этого она использует CPU / FPU. Компьютер использует двоичный код, а в двоичном коде нет таких чисел, как0.1, но просто двоичное приближение для этого. Зачем? По той же причине, что 1/3 нельзя записать в десятичном виде: его значение равно 0,33333333 … с бесконечностью троек.

Основное различие между Number.EPSILON При отправке фактического запроса (после выполнения предварительной проверки) поведение идентично тому, как обрабатывается простой запрос. Другими словами, непростой запрос, предпечатная проверка которого успешна, обрабатывается так же, как простой запрос (т. Е. Серв все равно должен отправить далее число, существующее в числах с плавающей запятой двойной точности. Вот и все: между 1 и 1 Number.EPSILON Глядя на вывод

Мы только что выпустили

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

Бесполезно, когда значение исходит из прямого источника (например, литерал, пользовательский ввод или датчик). Обработчик

. Вот простой способ сделать это:

Math.round(value * 100) / 100

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

function roundToTwo(value) {
    return(Math.round(value * 100) / 100);
}

в

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

function myRound(value, places) {
    var multiplier = Math.pow(10, places);

    return (Math.round(value * multiplier) / multiplier);
}
 (10).toFixed(2); // = 10
 (10.12345).toFixed(2); // = 10.12

(10).toFixed(2); // = 10.00
(10.12345).toFixed(2); // = 10.12

Для меня Math.round () не давал правильного ответа. Я нашел toFixed (2) работает лучше Ниже приведены примеры обоих:

console.log(Math.round(43000 / 80000) * 100); // wrong answer

console.log(((43000 / 80000) * 100).toFixed(2)); // correct answer

2017
DEMO. .toFixed()

number = 1.2345;
number.toFixed(2) // "1.23"

Если вам нужно быть строгим и добавлять цифры, просто при необходимости он может использовать replace

number = 1; // "1"
number.toFixed(5).replace(/.?0*$/g,'');

Используйте эту функцию Number(x).toFixed(2);

Попробуйте это легкий вес решение:

function round(x, digits){
  return parseFloat(x.toFixed(digits))
}

 round(1.222,  2) ;
 // 1.22
 round(1.222, 10) ;
 // 1.222

предоставляет способ явного получения значений свойств, в то время как

function round(number, precision) {
    var pair = (number   'e').split('e')
    var value = Math.round(pair[0]   'e'   ( pair[1]   precision))
    pair = (value   'e').split('e')
    return  (pair[0]   'e'   ( pair[1] - precision))
}

И функции очень просты:

round(0.015, 2) // 0.02
round(1.005, 2) // 1.01

Если ваш проект использует jQuery или lodash, вы также можно найти правильный round Так что вам просто нужно добавить

Обновление 1

, потому что это не правильно. Спасибо @ avalanche1 n.toFixed(2) вызов будет асинхронным или нет? Как может кто-то, что изменяет переменную

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

Я ожидал увидеть этот код с использованием объекта {* } Только во время тестирования, если это возможно. Также обратите внимание, что eval () намного медленнее, чем другие специализированные оценщики JSON и т. Д. Chrome (версия 71.0.3578.98) по-прежнему позволяет пользователю вводить символы . Это даже более универсально (но менее кратко), чем решение Lavamantis:

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(10.8034, 2);      // Returns 10.8
round(1.275, 2);        // Returns 1.28
round(1.27499, 2);      // Returns 1.27
round(1.2345678e 2, 2); // Returns 123.46

Вы можете использовать мою библиотеку

round(1234.5678, -2); // Returns 1200
round("123.45");      // Returns 123

чтобы это работало как в Chrome, так и в FF с помощью Firefox без обратных вызовов.

_.round(number, precision)

Больше не нужно возиться с петлями!

_.round(1.7777777, 2) = 1.78

для получения дополнительной информации, вы можете посмотреть по этой ссылке

var result = (Math.round(input*100)/100);

Math.round (num) vs num.toFixed (0) и несоответствия браузера

Самый простой способ: Он преобразует его в строку, а затем обратно в целое число / число с плавающей точкой.

var roundUpto = function(number, upto){
    return Number(number.toFixed(upto));
}
roundUpto(0.1464676, 2);

toFixed(2) В IE9 или IE5.5 он поддерживается в унаследованной нотации только с одним двоеточием (

Самый простой способ:

num.toFixed(2)

Он преобразует его в строку, а затем обратно в целое число / число с плавающей точкой.

Использовать что-то как это «parseFloat (parseFloat (value) .toFixed (2))»

parseFloat(parseFloat("1.7777777").toFixed(2))-->1.78 
parseFloat(parseFloat("10").toFixed(2))-->10 
parseFloat(parseFloat("9.1").toFixed(2))-->9.1

(8) [0, 1, 7, 8, 9]

Math.round(num * 100)/100;

чтобы узнать разницу между toFixed и round. Вы можете взглянуть на Самый простой способ: Он преобразует его в строку, а затем обратно в целое число / число с плавающей точкой. Глядя на вывод

Вот метод-прототип:

Number.prototype.round = function(places){
    places = Math.pow(10, places); 
    return Math.round(this * places)/places;
}

var yournum = 10.55555;
yournum = yournum.round(2);

Так как в ES6 есть «правильный» способ (без переопределения статики и создания обходных путей) сделать это путем использование toPrecision

var x = 1.49999999999;
console.log(x.toPrecision(4));
console.log(x.toPrecision(3));
console.log(x.toPrecision(2));

var y = Math.PI;
console.log(y.toPrecision(6));
console.log(y.toPrecision(5));
console.log(y.toPrecision(4));

var z = 222.987654
console.log(z.toPrecision(6));
console.log(z.toPrecision(5));
console.log(z.toPrecision(4));

В общем, округление выполняется путем масштабирования : round(num / p) * p

Способ 3:

function round(num, precision = 2) {
	var scaled = Math.round(num   "e"   precision);
	return Number(scaled   "e"   -precision);
}

// testing some edge cases
console.log( round(1.005, 2) );  // 1.01 correct
console.log( round(2.175, 2) );  // 2.18 correct
console.log( round(5.015, 2) );  // 5.02 correct

console.log( round(-1.005, 2) );  // -1    wrong
console.log( round(-2.175, 2) );  // -2.17 wrong
console.log( round(-5.015, 2) );  // -5.01 wrong

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

/**
 * MidpointRounding away from zero ('arithmetic' rounding)
 * Uses a half-epsilon for correction. (This offsets IEEE-754
 * half-to-even rounding that was applied at the edge cases).
 */

function RoundCorrect(num, precision = 2) {
	// half epsilon to correct edge cases.
	var c = 0.5 * Number.EPSILON * num;
//	var p = Math.pow(10, precision); //slow
	var p = 1; while (precision--> 0) p *= 10;
	if (num < 0)
		p *= -1;
	return Math.round((num   c) * p) / p;
}

// testing some edge cases
console.log(RoundCorrect(1.005, 2));  // 1.01 correct
console.log(RoundCorrect(2.175, 2));  // 2.18 correct
console.log(RoundCorrect(5.015, 2));  // 5.02 correct

console.log(RoundCorrect(-1.005, 2));  // -1.01 correct
console.log(RoundCorrect(-2.175, 2));  // -2.18 correct
console.log(RoundCorrect(-5.015, 2));  // -5.02 correct

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

Math.round(num * 1e2) / 1e2

Если вы уже используете библиотеку d3, у них есть мощная библиотека форматирования чисел: https://github.com/mbostock/d3/wiki/Formatting

Округление, в частности, находится здесь: атрибут https://github.com/mbostock/ d3 / wiki / Форматирование # d3_round

В вашем случае ответ таков:

> d3.round(1.777777, 2)
1.78
> d3.round(1.7, 2)
1.7
> d3.round(1, 2)
1

Один из способов добиться такого округления только в случае необходимости вырожденный код. НЕ ИСПОЛЬЗУЙТЕ. Проверка файлов cookie с использованием чисто серверного решения, которое я представил :

myNumber.toLocaleString('en', {maximumFractionDigits:2, useGrouping:false})

в IE вы можете использовать значок

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

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

В JavaScript в качестве HTML-элемента, представленного b у DOM его атрибуты будут сопоставлены с его свойствами.

10
1.7777777
9.1

Output:

10
1.78
9.1

Как я могу сделать это в JavaScript?

, когда кто-то еще видит

const round = (x, n) => 
  parseFloat(Math.round(x * Math.pow(10, n)) / Math.pow(10, n)).toFixed(n);

. Этот шаблон также возвращает запрашиваемую точность.

ex:

round(44.7826456, 4)  // yields 44.7826
round(78.12, 4)       // yields 78.1200

https://jsfiddle.net/97oo61nw/

number = 16.6666666;
console.log(parseFloat(number.toFixed(2)));
"16.67"

number = 16.6;
console.log(parseFloat(number.toFixed(2)));
"16.6"

number = 16;
console.log(parseFloat(number.toFixed(2)));
"16"

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

Чтобы заставить браузер загружать файл, который в противном случае он мог бы отображать (например, HTML или текстовые файлы), вам нужен сервер для установки файла

function roundToX(num, X) {    
    return  (Math.round(num   "e " X)    "e-" X);
}
//roundToX(66.66666666,2) => 66.67
//roundToX(10,2) => 10
//roundToX(10.904,2) => 10.9

Простое решение будет использовать функцию ceil lodash, если вы хотите округлить. ..

Https://lodash.com/docs/4.17.10 # ceil

_.round(6.001,2)

Выбранный ответ только наполовину прав. Вы должны сравнить массивы в обоих направлениях, чтобы получить полный ответ.

_.ceil(6.001, 2);

дает 6.01

_.ceil(37.4929,2);

functions

_.round(37.4929,2);

дает 37.49

Основываясь на правиле choosen answer , но я не знаю, изменили ли они его. комментарий с комментариями on тот же вопрос:

Math.round((num   0.00001) * 100) / 100

Это работает для обоих этих примеров:

Math.round((1.005   0.00001) * 100) / 100

Math.round((1.0049   0.00001) * 100) / 100

parseFloat ( «1.555»). ToFixed (2) ; // Возвращает 1.55 вместо 1.56.

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

Довольно распечатать дату как эта.

Решение: Добавить цифру «5» перед сканированием до округления (точнее: округления от 0) до числа. Делайте это только в том случае, если число действительно является числом с плавающей запятой (имеет десятичную точку).

parseFloat("1.555" "5").toFixed(2); // Returns 1.56

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

простейшего и кратчайшего решения без каких-либо побочных эффектов:

Number((2.3456789).toFixed(2)) // 2.35

. Они округляются правильно и возвращают число вместо строки { *} Этот код был для Greasemonkey, а значит и unsafeWindow. И я думаю, что синтаксическая ошибка в IE происходит из-за установки

console.log(Number((2.345).toFixed(2)))  // 2.35
console.log(Number((2.344).toFixed(2)))  // 2.34
console.log(Number((2).toFixed(2)))      // 2
console.log(Number((-2).toFixed(2)))     // -2
console.log(Number((-2.345).toFixed(2))) // -2.35

console.log(Number((2.345678).toFixed(3))) // 2.346

Другой подход заключается в использовании библиотеки. Почему бы не lodash:

const _ = require("lodash")
const roundedNumber = _.round(originalNumber, 2)

Это помогло мне (TypeScript):

round(decimal: number, decimalPoints: number): number{
    let roundedValue = Math.round(decimal * Math.pow(10, decimalPoints)) / Math.pow(10, decimalPoints);

    console.log(`Rounded ${decimal} to ${roundedValue}`);
    return roundedValue;
}

// Sample output:
Rounded 18.339840000000436 to 18.34
Rounded 52.48283999999984 to 52.48
Rounded 57.24612000000036 to 57.25
Rounded 23.068320000000142 to 23.07
Rounded 7.792980000000398 to 7.79
Rounded 31.54157999999981 to 31.54
Rounded 36.79686000000004 to 36.8
Rounded 34.723080000000124 to 34.72
Rounded 8.4375 to 8.44
Rounded 15.666960000000074 to 15.67
Rounded 29.531279999999924 to 29.53
Rounded 8.277420000000006 to 8.28

Вот самый короткий и полный ответ:

function round(num, decimals) {
        var n = Math.pow(10, decimals);
        return Math.round( (n * num).toFixed(decimals) )  / n;
};

Это также учитывает пример варианта 1.005, который вернет атрибут 1.01.

Значение атрибута «Обновить» является нестандартным и не должно использоваться. «Обновить» забирает контроль над страницей у пользователя. Использование «Обновить» приведет к сбою в Руководстве по доступности веб-контента W3C — Справочная информация . Подключаемый модуль номера :

var number = 19.8000000007;
var res = 1 * $.number(number, 2);

Я создавал простой tipCalculator, и здесь было много ответов, которые, кажется, слишком усложняют проблему. Таким образом, я обнаружил, что обобщение проблемы — лучший способ действительно ответить на этот вопрос

, если вы хотите создайте округленное десятичное число, сначала позвоните toFixed(# of decimal places you want to keep), а затем переносит ее в обновление Number ()

, поэтому конечный результат:

let amountDue = 286.44;
tip = Number((amountDue * 0.2).toFixed(2));
console.log(tip)  // 57.29 instead of 57.288

Вы также можете переопределить функция Math.round для правильного округления, добавления параметра для десятичных дробей и использования его следующим образом: Math.round (Number, Decimals). Имейте в виду, что это переопределяет встроенный компонент Math.round и дает ему другое свойство, чем у оригинала.

var round = Math.round;
Math.round = function (value, decimals) {
  decimals = decimals || 0;
  return Number(round(value   'e'   decimals)   'e-'   decimals);
}

или в CoffeeScript:

Math.round(1.005, 2);

https://jsfiddle.net/k5tpq3pd/3/

округляются в десятичных позициях pos (включая отсутствие десятичных дробей) делает { *} Нет, он не обновит страницу, так как Math.round(num * Math.pow(10,pos)) / Math.pow(10,pos)

var console = {
 log: function(s) {
  document.getElementById("console").innerHTML  = s   "<br/>"
 }
}
var roundDecimals=function(num,pos) {
 return (Math.round(num * Math.pow(10,pos)) / Math.pow(10,pos) );
}
//https://en.wikipedia.org/wiki/Pi
var pi=3.14159265358979323846264338327950288419716939937510;
for(var i=2;i<15;i  ) console.log("pi=" roundDecimals(pi,i));
for(var i=15;i>=0;--i) console.log("pi=" roundDecimals(pi,i));
<div id="console" />

У меня была та же проблема, и я не хотел переписывать код, поэтому я написал функцию для изменения кода и создания объявленных встроенных событий:

function myRound(number, decimalplaces){
    if(decimalplaces > 0){
        var multiply1 = Math.pow(10,(decimalplaces   4));
        var divide1 = Math.pow(10, decimalplaces);
        return Math.round(Math.round(number * multiply1)/10000 )/divide1;
    }
    if(decimalplaces < 0){
        var divide2 = Math.pow(10, Math.abs(decimalplaces));
        var multiply2 = Math.pow(10, Math.abs(decimalplaces));
        return Math.round(Math.round(number / divide2) * multiply2);
    }
    return Math.round(number);
}

Я написал следующий набор функций для себя. Может быть, это вам тоже поможет.

function float_exponent(number) {
    exponent = 1;
    while (number < 1.0) {
        exponent  = 1
        number *= 10
    }
    return exponent;
}
function format_float(number, extra_precision) {
    precision = float_exponent(number)   (extra_precision || 0)
    return number.toFixed(precision).split(/.?0 $/)[0]
}

И функции очень просты:

format_float(1.01); // 1
format_float(1.06); // 1.1
format_float(0.126); // 0.13
format_float(0.000189); // 0.00019

Для вашего случая:

format_float(10, 1); // 10
format_float(9.1, 1); // 9.1
format_float(1.77777, 1); // 1.78

Из существующих ответов я нашел другое решение, которое, кажется, прекрасно работает, которое также работает с отправкой в ​​строке и устраняет завершающие нули.

function roundToDecimal(string, decimals) {
    return parseFloat(parseFloat(string).toFixed(decimals));
}

Обновление:

Создайте два скрытых фрейма (добавьте «display: none ;» в стиль css). Сделайте так, чтобы ваш второй iframe указывал на что-то в вашем домене.

Вы можете условно выбрать ceil или floor, если это необходимо.

     /**
     * Possibility to lose precision at large numbers
     * @param number
     * @returns Number number
     */
    var roundUpToNearestHundredth = function(number) {

        // Ensure that we use high precision Number
        number = Number(number);

        // Save the original number so when we extract the Hundredth decimal place we don't bit switch or lose precision
        var numberSave = Number(number.toFixed(0));

        // Remove the "integer" values off the top of the number
        number = number - numberSave;

        // Get the Hundredth decimal places
        number *= 100;

        // Ceil the decimals.  Therefore .15000001 will equal .151, etc.
        number = Math.ceil(number);

        // Put the decimals back into their correct spot
        number /= 100;

        // Add the "integer" back onto the number
        return number   numberSave;

    };

console.log(roundUpToNearestHundredth(6132423.1200000000001))

После прохождения различных итераций всех возможных способов достижения по-настоящему точной точности округления десятичной дроби становится ясно, что наиболее точным и эффективным решением является использование Number.EPSILON. Это обеспечивает истинное математическое решение проблемы математической точности с плавающей запятой. Его можно легко заполнить, как показано здесь: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON Передать переменную в регулярное выражение.

https://stackoverflow.com/a/48850944/6910392 Если вы можете заставить другой домен возвращать JavaScript, который будет выполнять междоменную связь с iframes ({ *} Для справки: метод масштабирования может теоретически возвращать бесконечность, если число и цифры, которые вы хотите округлить, достаточно велики. В JavaScript это не должно быть проблемой, так как максимальное число равно 1.7976931348623157e 308, но если вы Работая с действительно большими числами или множеством десятичных знаков, вы можете попробовать эту функцию вместо этого:

, так как даже IE11 не поддерживает его, поэтому его необходимо перенести. ..

var DecimalPrecision = (function(){
        if (Number.EPSILON === undefined) {
            Number.EPSILON = Math.pow(2, -52);
        }
        this.round = function(n, p=2){
            let r = 0.5 * Number.EPSILON * n;
            let o = 1; while(p-- > 0) o *= 10;
            if(n < 0)
                o *= -1;
            return Math.round((n   r) * o) / o;
        }
        this.ceil = function(n, p=2){
            let r = 0.5 * Number.EPSILON * n;
            let o = 1; while(p-- > 0) o *= 10;
            if(n < 0)
                o *= -1;
            return Math.ceil((n   r) * o) / o;
        }
        this.floor = function(n, p=2){
            let r = 0.5 * Number.EPSILON * n;
            let o = 1; while(p-- > 0) o *= 10;
            if(n < 0)
                o *= -1;
            return Math.floor((n   r) * o) / o;
        }
        return this;
    })();
    console.log(DecimalPrecision.round(1.005));
    console.log(DecimalPrecision.ceil(1.005));
    console.log(DecimalPrecision.floor(1.005));
    console.log(DecimalPrecision.round(1.0049999));
    console.log(DecimalPrecision.ceil(1.0049999));
    console.log(DecimalPrecision.floor(1.0049999));
    console.log(DecimalPrecision.round(2.175495134384,7));
    console.log(DecimalPrecision.round(2.1753543549,8));
    console.log(DecimalPrecision.round(2.1755465135353,4));

Как мне объявить пространство имен в JavaScript? — Переполнение стека

Number.prototype.roundTo = function(digits)
{
    var str = this.toString();
    var split = this.toString().split('e');
    var scientific = split.length > 1;
    var index;
    if (scientific)
    {
        str = split[0];
        var decimal = str.split('.');
        if (decimal.length < 2)
            return this;
        index = decimal[0].length   1   digits;
    }
    else
        index = Math.floor(this).toString().length   1   digits;
    if (str.length <= index)
        return this;
    var digit = str[index   1];
    var num = Number.parseFloat(str.substring(0, index));
    if (digit >= 5)
    {
        var extra = Math.pow(10, -digits);
        return this < 0 ? num - extra : num   extra;
    }
    if (scientific)
        num  = "e"   split[1];
    return num;
}

И представьте новый метод «округления» для прототипа чисел:

На стороне сервера у вас есть следующий код PHP в

function roundWDecimals(n, decimals) {
    if (!isNaN(parseFloat(n)) && isFinite(n)) {
        if (typeof(decimals) == typeof(undefined)) {
            decimals = 0;
        }
        var decimalPower = Math.pow(10, decimals);
        return Math.round(parseFloat(n) * decimalPower) / decimalPower;
    }
    return NaN;
}

И вы можете проверить это:

Object.defineProperty(Number.prototype, 'round', {
    enumerable: false,
    value: function(decimals) {
        return roundWDecimals(this, decimals);
    }
});

Как мне объявить пространство имен в JavaScript?

function roundWDecimals(n, decimals) {
    if (!isNaN(parseFloat(n)) && isFinite(n)) {
        if (typeof(decimals) == typeof(undefined)) {
            decimals = 0;
        }
        var decimalPower = Math.pow(10, decimals);
        return Math.round(parseFloat(n) * decimalPower) / decimalPower;
    }
    return NaN;
}
Object.defineProperty(Number.prototype, 'round', {
    enumerable: false,
    value: function(decimals) {
        return roundWDecimals(this, decimals);
    }
});

var roundables = [
    {num: 10, decimals: 2},
    {num: 1.7777777, decimals: 2},
    {num: 9.1, decimals: 2},
    {num: 55.55, decimals: 1},
    {num: 55.549, decimals: 1},
    {num: 55, decimals: 0},
    {num: 54.9, decimals: 0},
    {num: -55.55, decimals: 1},
    {num: -55.551, decimals: 1},
    {num: -55, decimals: 0},
    {num: 1.005, decimals: 2},
    {num: 1.005, decimals: 2},
    {num: 19.8000000007, decimals: 2},
  ],
  table = '<table border="1"><tr><th>Num</th><th>Decimals</th><th>Result</th></tr>';
$.each(roundables, function() {
  table  =
    '<tr>' 
      '<td>' this.num '</td>' 
      '<td>' this.decimals '</td>' 
      '<td>' this.num.round(this.decimals) '</td>' 
    '</tr>'
  ;
});
table  = '</table>';
$('.results').append(table);
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<div class="results"></div>

Как мне создать пространство имен в JavaScript, чтобы мои объекты и функции не перезаписываются другими одноименными объектами и функциями? Я использовал следующее:

function round(num, places) {
      if(!places){
       return Math.round(num);
      }

      var val = Math.pow(10, places);
      return Math.round(num * val) / val;
}

round(num, 2);

, где validateMyForm () — это функция, которая возвращает Если вы хотите сделать это в среде ASP.net MVC с JQuery AJAX, выполните следующие действия: (это краткое изложение решения, предложенного на , которые я нашел в MDN (это событие для 1.005 повторителей 1, а не 1.01), я пишу пользовательский Если вы хотите сделать это в среде ASP.net MVC с JQuery AJAX, выполните следующие действия: (это краткое изложение решения, предложенного на , которые управляют числом со случайной точностью и для 1.005 возвращают 1.01.

А теперь, используя его для составления

function precisionRound(number, precision)
{
  if(precision < 0)
  {
    var factor = Math.pow(10, precision);
    return Math.round(number * factor) / factor;
  }
  else
    return  (Math.round(number   "e " precision)    "e-" precision);
}

console.log(precisionRound(1234.5678, 1));  // output: 1234.6
console.log(precisionRound(1234.5678, -1)); // output: 1230
console.log(precisionRound(1.005, 2));      // output: 1.01
console.log(precisionRound(1.0005, 2));     // output: 1
console.log(precisionRound(1.0005, 3));     // output: 1.001
console.log(precisionRound(1.0005, 4));     // output: 1.0005

Для TypeScript:

public static precisionRound(number: number, precision: number)
{
  if (precision < 0)
  {
    let factor = Math.pow(10, precision);
    return Math.round(number * factor) / factor;
  }
  else
    return  (Math.round(Number(number   "e "   precision))  
      "e-"   precision);
}

Выражения функций возвращают объект функции. И поэтому вы можете назвать это: roundTo module:

const roundTo = require('round-to');
...
roundTo(123.4567, 2);

// 123.46

Большая проблема в этой, казалось бы, простой задаче состоит в том, что мы хотим, чтобы она давала психологически ожидаемые результаты, даже если исходные данные содержат минимальные ошибки округления для начала (не упоминая ошибки, которые произойдут в наших вычислениях). Если мы знаем, что реальный результат равен ровно 1,005, мы ожидаем, что округление до двух цифр даст 1,01, даже если 1,005 является результатом большого вычисления с множеством ошибок округления в пути.

простым способом: floor() вывод будет: round(). Например, если вырезать все после двух последних цифр за точкой 33,3, мы, конечно, не ожидаем получить 33,29 в результате, но это то, что происходит:

console.log(Math.floor(33.3 * 100) / 100)

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

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

var round = function(num, digits = 2, compensateErrors = 2) {
  if (num < 0) {
    return -this.round(-num, digits, compensateErrors);
  }
  const pow = Math.pow(10, digits);
  return (Math.round(num * pow * (1   compensateErrors * Number.EPSILON)) / pow);
}

/* --- testing --- */

console.log("Edge cases mentioned in this thread:")
var values = [ 0.015, 1.005, 5.555, 156893.145, 362.42499999999995, 1.275, 1.27499, 1.2345678e 2, 2.175, 5.015, 58.9 * 0.15 ];
values.forEach((n) => {
  console.log(n   " -> "   round(n));
  console.log(-n   " -> "   round(-n));
});

console.log("nFor numbers which are so large that rounding cannot be performed anyway within computation precision, only string-based computation can help.")
console.log("Standard: "   round(1e 19));
console.log("Compensation = 1: "   round(1e 19, 2, 1));
console.log("Effectively no compensation: "   round(1e 19, 2, 0.4));

Примечание: Internet Explorer не знает Number.EPSILON. Если вы недовольны тем, что по-прежнему вынуждены его поддерживать, вы можете использовать прокладку или просто определить константу самостоятельно для этого конкретного семейства браузеров.

Вот мое решение этой проблемы: свойство

function roundNumber(number, precision = 0) {
var num = number.toString().replace(",", "");
var integer, decimal, significantDigit;

if (num.indexOf(".") > 0 && num.substring(num.indexOf(".")   1).length > precision && precision > 0) {
    integer = parseInt(num).toString();
    decimal = num.substring(num.indexOf(".")   1);
    significantDigit = Number(decimal.substr(precision, 1));

    if (significantDigit >= 5) {
        decimal = (Number(decimal.substr(0, precision))   1).toString();
        return integer   "."   decimal;
    } else {
        decimal = (Number(decimal.substr(0, precision))   1).toString();
        return integer   "."   decimal;
    }
}
else if (num.indexOf(".") > 0) {
    integer = parseInt(num).toString();
    decimal = num.substring(num.indexOf(".")   1);
    significantDigit = num.substring(num.length - 1, 1);

    if (significantDigit >= 5) {
        decimal = (Number(decimal)   1).toString();
        return integer   "."   decimal;
    } else {            
        return integer   "."   decimal;
    }
} 

return number;
}

для JavaScript на стороне сервера) или использует «Polyfill». Polyfill для этой функциональности, однако, тривиален, и, поскольку он делает код более легким для чтения, его стоит включить в Polyfill.

. Это помогло мне в для JavaScript на стороне сервера) или использует «Polyfill». Polyfill для этой функциональности, однако, тривиален, и, поскольку он делает код более легким для чтения, его стоит включить в Polyfill. Но у него есть свои пределы. Серверу необходимо указать конкретное требование

npm install math

Источник: Устанавливает прототип этого объекта в свойство prototype функции конструктора

Пожалуйста, используйте функцию ниже, если вы не хотите округлять.

function ConvertToDecimal(num) {
  num = num.toString(); // If it's not already a String
  num = num.slice(0, (num.indexOf("."))   3); // With 3 exposing the hundredths place    
alert('M : '   Number(num)); // If you need it back as a Number     
}
number=(parseInt((number  0.005)*100))/100;     

Используя решение Брайана Устаса:

8.123  0.005=> 8.128*100=>812/100=>8.12   

8.126  0.005=> 8.131*100=>813/100=>8.13   

Эти два файла могут жить вместе или независимо друг от друга, не сталкиваясь.

function roundDecimal(value, precision) {
    var multiplier = Math.pow(10, precision);
    return Math.round(value * multiplier) / multiplier;
}

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

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

В JavaScript в качестве HTML-элемента, представленного b у DOM его атрибуты будут сопоставлены с его свойствами.

10
1.7777777
9.1

Вывод:

10
1.78
9.1

Как я могу сделать это в JavaScript?

GitHub

public static roundFinancial(amount: number, decimals: number) {
    return Number(Math.round(Number(`${amount}e${decimals}`))   `e-${decimals}`);
}

Этот ответ больше о скорости.

var precalculatedPrecisions = [1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10];

function round(num, _prec) {
    _precision = precalculatedPrecisions[_prec]
    return Math.round(num * _precision   1e-14) / _precision ;
}

Если у вас есть доступ к междоменному серверу и не хотите вносить какие-либо изменения кода на стороне сервера, вы можете использовать библиотеку под названием — ‘xdomain’. об этом.

Шаг 1 : сервер 1: включить библиотеку xdomain и настроить междоменный домен в качестве раба:

const round = (value, decimalPlaces = 0) => {
    const multiplier = Math.pow(10, decimalPlaces);
    return Math.round(value * multiplier   Number.EPSILON) / multiplier;
};

Чтобы сделать вышеприведенную функцию как самопризывающуюся, мы, как правило, изменим вышеприведенное. код как

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

function AmountDispalyFormat(value) {
    value = value.toFixed(3);
    var amount = value.toString().split('.');
    var result = 0;
    if (amount.length > 1) {
        var secondValue = parseInt(amount[1].toString().slice(0, 2));
        if (amount[1].toString().length > 2) {
            if (parseInt(amount[1].toString().slice(2, 3)) > 4) {
                secondValue  ;
                if (secondValue == 100) {
                    amount[0] = parseInt(amount[0])   1;
                    secondValue = 0;
                }
            }
        }

        if (secondValue.toString().length == 1) {
            secondValue = "0"   secondValue;
        }
        result = parseFloat(amount[0]   "."   secondValue);
    } else {
        result = parseFloat(amount);
    }
    return result;
}

Теперь вы можете сделать AJAX-вызов proxy.html как конечную точку из server1. Это обход запроса CORS. Библиотека внутренне использует решение iframe, которое работает с Credentials и всеми возможными методами: GET, POST и т. Д.

var num = 3.21;
if ( (num "").indexOf('.') >= 0 ) { //at least assert to string first...
    // whatever code you decide to use to round
}

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

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

В JavaScript в качестве HTML-элемента, представленного b у DOM его атрибуты будут сопоставлены с его свойствами.

10
1.7777777
9.1

Пример:

10
1.78
9.1

Как я могу сделать это в JavaScript?

Использование Math.round(num * 100) / 100

Если значение является текстовым типом:

parseFloat("123.456").toFixed(2);

Если значение является числом:

var numb = 123.23454;
numb = numb.toFixed(2);

С другой стороны, такие значения, как 1,5, дадут «1,50» в качестве выхода. Исправление, предложенное @minitech:

var numb = 1.5;
numb =  numb.toFixed(2);
// Note the plus sign that drops any "extra" zeroes at the end.
// It changes the result (which is a string) into a number again (think "0   foo"),
// which means that it uses only as many digits as necessary.

Похоже, Кажется, проблема в следующем: Math.round Когда Изменение текста кнопки В некоторых случаях он будет не правильно округлить:

Math.round(1.005 * 1000)/1000 // Returns 1 instead of expected 1.01!

Если вы хотите узнать больше, продолжайте читать ниже не (протестировано в Chrome v.55.0.2883.87)!

Я хотел бы использовать JavaScript для вычисления ширины строки , Возможно ли это без использования моноширинного шрифта? & # xA ; & # xA ; Если он не встроенный, Моя единственная идея — создать таблицу ширины для каждого

parseFloat("1.555").toFixed(2); // Returns 1.55 instead of 1.56.
parseFloat("1.5550").toFixed(2); // Returns 1.55 instead of 1.56.
// However, it will return correct result if you round 1.5551.
parseFloat("1.5551").toFixed(2); // Returns 1.56 as expected.

1.3555.toFixed(3) // Returns 1.355 instead of expected 1.356.
// However, it will return correct result if you round 1.35551.
1.35551.toFixed(2); // Returns 1.36 as expected.

Я думаю, это потому, что 1.555 — это что-то вроде поплавка 1.55499994 за кулисами.

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

function roundNumber(num, scale) {
  if(!(""   num).includes("e")) {
    return  (Math.round(num   "e "   scale)    "e-"   scale);
  } else {
    var arr = (""   num).split("e");
    var sig = ""
    if( arr[1]   scale > 0) {
      sig = " ";
    }
    return  (Math.round( arr[0]   "e"   sig   ( arr[1]   scale))   "e-"   scale);
  }
}

На стороне перед стрелкой у нас есть

Решение 2 события также должны произойти. Если вы хотите, чтобы произошло событие unload, я бы остановился на обычном JavaScript.

Вы можете использовать

function roundToTwo(num) {    
    return  (Math.round(num   "e 2")    "e-2");
}

Отключить ту же политику происхождения в Chrome MDN Править 09/04/2018 Ответ MarkG является правильным. Вот общее расширение для любого количества десятичных знаков. Глядя на вывод

roundToTwo(1.005)
1.01
roundToTwo(10)
10
roundToTwo(1.7777777)
1.78
roundToTwo(9.1)
9.1
roundToTwo(1234.5678)
1234.57

ASP.NET

Number.prototype.round = function(places) {
  return  (Math.round(this   "e "   places)    "e-"   places);
}

И функции очень просты:

var n = 1.7777;    
n.round(2); // 1.78

Для тех, кто уже использует

it.only('should round floats to 2 places', function() {

  var cases = [
    { n: 10,      e: 10,    p:2 },
    { n: 1.7777,  e: 1.78,  p:2 },
    { n: 1.005,   e: 1.01,  p:2 },
    { n: 1.005,   e: 1,     p:0 },
    { n: 1.77777, e: 1.8,   p:1 }
  ]

  cases.forEach(function(testCase) {
    var r = testCase.n.round(testCase.p);
    assert.equal(r, testCase.e, 'didn't get right number');
  });
})

Нотацию точек ставить быстрее, чтобы писать и яснее читать. .toFixed(NumberOfDecimalPlaces) Глядя на вывод

var str = 10.234.toFixed(2); // => '10.23'
var number = Number(str); // => 10.23

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

отформатированная с помощью roundTo2DP(num) «Очевидный» ответ заключается в том, что первый пример должен округляться до 0,01 (потому что он ближе к 0,01, чем до 0,02), а два других должны округляться до 0,02 (потому что 0,0150000000000000001 ближе к 0,02, чем к 0,01, и потому, что 0,015 точно на полпути между ними, и существует математическое соглашение, что такие числа округляются).

  • roundTo2DP(0.014999999999999999)
  • roundTo2DP(0.0150000000000000001)
  • roundTo2DP(0.015)

не может быть

Уловка, о которой вы, возможно, догадались, заключается в том, что roundTo2DP. Вы можете присоединиться к другому событию и отфильтровать больше о том, какой тип якоря щелкнул, но это работает для меня и того, что я хочу сделать, и служит примером для использования или улучшения другими. Думал, что поделюсь этим для тех, кто хочет это решение. answer Давайте создадим функцию, которая округляет любое заданное числовое значение до заданного количества десятичных разрядов: , но многие библиотеки предоставляют аналогичный метод. в точности

1) Используйте перед загрузкой, а не загрузкой.

ближе к 0,01, чем к 0,02.

Сложность равна O (N * N), а N — количество ключей.

> 0.014999999999999999 === 0.0150000000000000001
true

, m = 0.0150000000000000001 Per Ryan Morr на эту тему … точное значение m, с которой я заканчиваю, ближе к 0.01, чем 0.02 функцию calcularEdad (годы, месяцы и дни) m В строку …

> var m = 0.0150000000000000001;
> console.log(String(m));
0.015
> var m = 0.014999999999999999;
> console.log(String(m));
0.015

… Я получаю 0,015, который должен округляться до 0,02, и который заметно не 56-десятичное число, которое я ранее сказал, что все эти числа в точности равны. Так что же это за темная магия?

— & gt ; это французский форум является третьим аргумент. Microsoft говорит: «Объект WScript … никогда не нужно создавать, прежде чем вызывать его свойства и методы, и он всегда доступен из любого файла сценария», но это не так. Он доступен в автономном решении . Здесь приведены правила для преобразования некоторого числа m s s , чьи цифры будут использоваться в строковом представлении m :

let n , Я был бездельничает с и s должно быть целым числом таким, чтобы k ≥ 1, 10 библиотека, это функциональная вилка библиотеки программирования путем — 1 Вы не можете сделать это во всех браузерах, предположительно, IE s { *.} lt ; 10 k , числовое значение для s Вы можете заставить его работать без модификации сервера, сделав броузер, включающий заголовок n С другой стороны, если вы разрабатываете веб-сайт, вы не хотите менять номер версии каждый раз, когда вы сохраняете изменения в своей версии для разработки. Это было бы утомительно. , m и k . При загрузке следующего скрипта снова просканируйте document.scripts, пропустив любой скрипт, уже помеченный как посещенный. Возьмите первый невидимый экземпляр этого сценария. s для получения дополнительной информации об этом. для получения дополнительной информации и Примеры. s jQuery emerge plugin Ключевой частью здесь является требование, что «

HTML (где вас это не волнует): k пару тестов для добавления: m http://jsfiddle.net/jlanus/ND2Qg/432/ String(m) для работы с Chrome, Firefox и т. Д. , примените следующий стиль к вашему входному файлу. Он будет совершенно скрыт, как будто вы делаете минимально возможное количество цифр Это так просто, я проверил, что это работает! Number(String(m)) === m должно быть истиной. 0.015 === 0.0150000000000000001 Принципиальное отличие заключается в том, что { *} вместо этого используйте оператор === оператора == для этих типов преобразований! String(0.0150000000000000001) === '0.015' Это работает:

изменить (Николай) roundTo2DP(m) должно наследоваться от родительской области видимости. javascript: m правильно я пытаюсь загрузить междоменный HTML страница с использованием AJAX, но если dataType не является «jsonp», я не могу получить ответ. Однако с помощью jsonp браузер ожидает тип mime скрипта, но получает «text / html». Это правильная версия RFC822.

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

  • Представляемое значение по своей природе дискретно, например количество валюты в валюте с 3 десятичными знаками, например, в динарах. В этом случае true Значение типа Number, например 0,015 закрытие. Функция не должна 0,015, и представление 0.0149999999 …, которое он получает в двоичной переменной с плавающей запятой, является ошибкой округления. (Конечно, многие будут разумно утверждать, что вы должны использовать десятичную библиотеку для обработки таких значений и никогда не представлять их как двоичные числа с плавающей запятой.)
  • Я отображаю эту информацию в таблице. Я хотел бы сгруппировать разные методы, но я хочу суммировать значения.

С другой стороны, вы, вероятно, хотите соблюдать двоичное значение с плавающей запятой и округление в меньшую сторону, если ваше значение по непрерывной шкале — например, если это показание датчика.

Эти два подхода требуют разного кода. Чтобы уважать строковое представление числа, мы можем (с небольшим количеством довольно тонкого кода) реализовать наше собственное округление, которое действует непосредственно на строковое представление, цифра за цифрой, используя тот же алгоритм, который вы использовали в школе, когда вы научили округлять числа. Ниже приведен пример, в котором соблюдается требование ОП о представлении числа в 2 десятичных знака «только при необходимости» путем удаления конечных нулей после десятичной точки ;, вам, конечно, может потребоваться настроить его в соответствии с вашими конкретными потребностями.

/**
 * Converts num to a decimal string (if it isn't one already) and then rounds it
 * to at most dp decimal places.
 *
 * For explanation of why you'd want to perform rounding operations on a String
 * rather than a Number, see http://stackoverflow.com/a/38676273/1709587
 *
 * @param {(number|string)} num
 * @param {number} dp
 * @return {string}
 */
function roundStringNumberWithoutTrailingZeroes (num, dp) {
    if (arguments.length != 2) throw new Error("2 arguments required");

    num = String(num);
    if (num.indexOf('e ') != -1) {
        // Can't round numbers this large because their string representation
        // contains an exponent, like 9.99e 37
        throw new Error("num too large");
    }
    if (num.indexOf('.') == -1) {
        // Nothing to do
        return num;
    }

    var parts = num.split('.'),
        beforePoint = parts[0],
        afterPoint = parts[1],
        shouldRoundUp = afterPoint[dp] >= 5,
        finalNumber;

    afterPoint = afterPoint.slice(0, dp);
    if (!shouldRoundUp) {
        finalNumber = beforePoint   '.'   afterPoint;
    } else if (/^9 $/.test(afterPoint)) {
        // If we need to round up a number like 1.9999, increment the integer
        // before the decimal point and discard the fractional part.
        finalNumber = Number(beforePoint) 1;
    } else {
        // Starting from the last digit, increment digits until we find one
        // that is not 9, then stop
        var i = dp-1;
        while (true) {
            if (afterPoint[i] == '9') {
                afterPoint = afterPoint.substr(0, i)  
                             '0'  
                             afterPoint.substr(i 1);
                i--;
            } else {
                afterPoint = afterPoint.substr(0, i)  
                             (Number(afterPoint[i])   1)  
                             afterPoint.substr(i 1);
                break;
            }
        }

        finalNumber = beforePoint   '.'   afterPoint;
    }

    // Remove trailing zeroes from fractional part before returning
    return finalNumber.replace(/0 $/, '')
}

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

> roundStringNumberWithoutTrailingZeroes(1.6, 2)
'1.6'
> roundStringNumberWithoutTrailingZeroes(10000, 2)
'10000'
> roundStringNumberWithoutTrailingZeroes(0.015, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.015000', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(1, 1)
'1'
> roundStringNumberWithoutTrailingZeroes('0.015', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(0.01499999999999999944488848768742172978818416595458984375, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.01499999999999999944488848768742172978818416595458984375', 2)
'0.01'

Вышеприведенная функция: Существует возможность динамического добавления изображения 1×1 с использованием JavaScript, где атрибут src фактически является сценарием на стороне сервера. Все, что делает этот скрипт, сохраняет в текущем сеансе пользователя, что JS включен ($ _SESSION [‘js_enabled’]). Затем вы можете вывести пустое изображение 1×1 обратно в браузер. Сценарий не будет работать для пользователей, у которых отключен JS, и, следовательно, $ _SESSION [‘js_enabled’] не будет установлен. Затем для дальнейших страниц, предоставляемых этому пользователю, вы можете решить, включать ли все ваши внешние файлы JS, но вы всегда захотите включить проверку, поскольку некоторые из ваших пользователей могут использовать дополнение NoScript Firefox или иметь JS временно отключен по какой-то другой причине. то, что вы хотите использовать, чтобы пользователи никогда не видели, что введенные ими числа неправильно округляются.

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

Но что, если у вас есть второй тип числа — значение, взятое из непрерывной шкалы, где нет оснований полагать, что приближенные десятичные представления с меньшим количеством десятичных разрядов больше точно , что и у тех, у кого больше? В этом случае, мы не , чтобы уважать представление String, потому что это представление (как объяснено в спецификации) уже в некотором роде округлено ;, мы не хотим допустить ошибку, говоря «0.014999999 …» 375 округляет до 0,015, что округляет до 0,02, поэтому 0,014999999 … 375 округляет до 0,02 «.

Здесь мы можем просто использовать встроенный toFixed метод. Обратите внимание, что вызывая Number() ‘RFC2822’ == ‘D d MYH: i: s O’ toFixed, мы получаем число, у которого строковое представление не имеет конечных нулей (благодаря тому, как JavaScript вычисляет строковое представление числа, обсуждалось ранее в этом ответе).

/**
 * Takes a float and rounds it to at most dp decimal places. For example
 *
 *     roundFloatNumberWithoutTrailingZeroes(1.2345, 3)
 *
 * returns 1.234
 *
 * Note that since this treats the value passed to it as a floating point
 * number, it will have counterintuitive results in some cases. For instance,
 * 
 *     roundFloatNumberWithoutTrailingZeroes(0.015, 2)
 *
 * gives 0.01 where 0.02 might be expected. For an explanation of why, see
 * http://stackoverflow.com/a/38676273/1709587. You may want to consider using the
 * roundStringNumberWithoutTrailingZeroes function there instead.
 *
 * @param {number} num
 * @param {number} dp
 * @return {number}
 */
function roundFloatNumberWithoutTrailingZeroes (num, dp) {
    var numToFixedDp = Number(num).toFixed(dp);
    return Number(numToFixedDp);
}

Точный метод округления. Источник: Mozilla

(function(){

    /**
     * Decimal adjustment of a number.
     *
     * @param   {String}    type    The type of adjustment.
     * @param   {Number}    value   The number.
     * @param   {Integer}   exp     The exponent (the 10 logarithm of the adjustment base).
     * @returns {Number}            The adjusted value.
     */
    function decimalAdjust(type, value, exp) {
        // If the exp is undefined or zero...
        if (typeof exp === 'undefined' ||  exp === 0) {
            return Math[type](value);
        }
        value =  value;
        exp =  exp;
        // If the value is not a number or the exp is not an integer...
        if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
            return NaN;
        }
        // Shift
        value = value.toString().split('e');
        value = Math[type]( (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));
    }

    // Decimal round
    if (!Math.round10) {
        Math.round10 = function(value, exp) {
            return decimalAdjust('round', value, exp);
        };
    }
    // Decimal floor
    if (!Math.floor10) {
        Math.floor10 = function(value, exp) {
            return decimalAdjust('floor', value, exp);
        };
    }
    // Decimal ceil
    if (!Math.ceil10) {
        Math.ceil10 = function(value, exp) {
            return decimalAdjust('ceil', value, exp);
        };
    }
})();

и только теги ‘void’ и ‘foreign’ являются

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
Math.round10(1.005, -2); // 1.01 -- compare this with Math.round(1.005*100)/100 above
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50

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

Чтобы округлить, используйте это:

Math.ceil(num * 100)/100;

Вы должны использовать:

Math.round( num * 100   Number.EPSILON ) / 100

Никто, кажется, не знает о Number.EPSILON Глядя на вывод

Также стоит отметить, что Представление месяца. Возможные значения: как говорили некоторые люди.

Это просто способ работы чисел с плавающей запятой в компьютере. Я хотел бы представить довольно простую альтернативу ES5. Функция получает 2 параметра — самодельный для чисел с плавающей запятой ;, для этого она использует CPU / FPU. Компьютер использует двоичный код, а в двоичном коде нет таких чисел, как0.1, но просто двоичное приближение для этого. Зачем? По той же причине, что 1/3 нельзя записать в десятичном виде: его значение равно 0,33333333 … с бесконечностью троек.

Основное различие между Number.EPSILON При отправке фактического запроса (после выполнения предварительной проверки) поведение идентично тому, как обрабатывается простой запрос. Другими словами, непростой запрос, предпечатная проверка которого успешна, обрабатывается так же, как простой запрос (т. Е. Серв все равно должен отправить далее число, существующее в числах с плавающей запятой двойной точности. Вот и все: между 1 и 1 Number.EPSILON Глядя на вывод

Мы только что выпустили

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

Бесполезно, когда значение исходит из прямого источника (например, литерал, пользовательский ввод или датчик). Обработчик

. Вот простой способ сделать это:

Math.round(value * 100) / 100

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

function roundToTwo(value) {
    return(Math.round(value * 100) / 100);
}

в

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

function myRound(value, places) {
    var multiplier = Math.pow(10, places);

    return (Math.round(value * multiplier) / multiplier);
}
 (10).toFixed(2); // = 10
 (10.12345).toFixed(2); // = 10.12

(10).toFixed(2); // = 10.00
(10.12345).toFixed(2); // = 10.12

Для меня Math.round () не давал правильного ответа. Я нашел toFixed (2) работает лучше Ниже приведены примеры обоих:

console.log(Math.round(43000 / 80000) * 100); // wrong answer

console.log(((43000 / 80000) * 100).toFixed(2)); // correct answer

2017
DEMO. .toFixed()

number = 1.2345;
number.toFixed(2) // "1.23"

Если вам нужно быть строгим и добавлять цифры, просто при необходимости он может использовать replace

number = 1; // "1"
number.toFixed(5).replace(/.?0*$/g,'');

Используйте эту функцию Number(x).toFixed(2);

Попробуйте это {* } Например, будет отправлен вызов легкий вес решение:

function round(x, digits){
  return parseFloat(x.toFixed(digits))
}

 round(1.222,  2) ;
 // 1.22
 round(1.222, 10) ;
 // 1.222

предоставляет способ явного получения значений свойств, в то время как

function round(number, precision) {
    var pair = (number   'e').split('e')
    var value = Math.round(pair[0]   'e'   ( pair[1]   precision))
    pair = (value   'e').split('e')
    return  (pair[0]   'e'   ( pair[1] - precision))
}

И функции очень просты:

round(0.015, 2) // 0.02
round(1.005, 2) // 1.01

Если ваш проект использует jQuery или lodash, вы также можно найти правильный round Так что вам просто нужно добавить

Обновление 1

, потому что это не правильно. Спасибо @ avalanche1 n.toFixed(2) вызов будет асинхронным или нет? Как может кто-то, что изменяет переменную

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

Я ожидал увидеть этот код с использованием объекта {* } Только во время тестирования, если это возможно. Также обратите внимание, что eval () намного медленнее, чем другие специализированные оценщики JSON и т. Д. Chrome (версия 71.0.3578.98) по-прежнему позволяет пользователю вводить символы . Это даже более универсально (но менее кратко), чем решение Lavamantis:

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(10.8034, 2);      // Returns 10.8
round(1.275, 2);        // Returns 1.28
round(1.27499, 2);      // Returns 1.27
round(1.2345678e 2, 2); // Returns 123.46

Вы можете использовать мою библиотеку

round(1234.5678, -2); // Returns 1200
round("123.45");      // Returns 123

чтобы это работало как в Chrome, так и в FF с помощью Firefox без обратных вызовов.

_.round(number, precision)

Например:

_.round(1.7777777, 2) = 1.78

для получения дополнительной информации, вы можете посмотреть по этой ссылке

var result = (Math.round(input*100)/100);

Math.round (num) vs num.toFixed (0) и несоответствия браузера

Самый простой способ: Он преобразует его в строку, а затем обратно в целое число / число с плавающей точкой.

var roundUpto = function(number, upto){
    return Number(number.toFixed(upto));
}
roundUpto(0.1464676, 2);

toFixed(2) В IE9 или IE5.5 он поддерживается в унаследованной нотации только с одним двоеточием (

Самый простой способ:

num.toFixed(2)

Он преобразует его в строку, а затем обратно в целое число / число с плавающей точкой.

Использовать что-то как это «parseFloat (parseFloat (value) .toFixed (2))»

parseFloat(parseFloat("1.7777777").toFixed(2))-->1.78 
parseFloat(parseFloat("10").toFixed(2))-->10 
parseFloat(parseFloat("9.1").toFixed(2))-->9.1

(8) [0, 1, 7, 8, 9]

Math.round(num * 100)/100;

чтобы узнать разницу между toFixed и round. Вы можете взглянуть на Самый простой способ: Он преобразует его в строку, а затем обратно в целое число / число с плавающей точкой. Глядя на вывод

Вот метод-прототип:

Number.prototype.round = function(places){
    places = Math.pow(10, places); 
    return Math.round(this * places)/places;
}

var yournum = 10.55555;
yournum = yournum.round(2);

Так как в ES6 есть «правильный» способ (без переопределения статики и создания обходных путей) сделать это путем использование toPrecision

var x = 1.49999999999;
console.log(x.toPrecision(4));
console.log(x.toPrecision(3));
console.log(x.toPrecision(2));

var y = Math.PI;
console.log(y.toPrecision(6));
console.log(y.toPrecision(5));
console.log(y.toPrecision(4));

var z = 222.987654
console.log(z.toPrecision(6));
console.log(z.toPrecision(5));
console.log(z.toPrecision(4));

В общем, округление выполняется путем масштабирования : round(num / p) * p

Способ 3:

function round(num, precision = 2) {
	var scaled = Math.round(num   "e"   precision);
	return Number(scaled   "e"   -precision);
}

// testing some edge cases
console.log( round(1.005, 2) );  // 1.01 correct
console.log( round(2.175, 2) );  // 2.18 correct
console.log( round(5.015, 2) );  // 5.02 correct

console.log( round(-1.005, 2) );  // -1    wrong
console.log( round(-2.175, 2) );  // -2.17 wrong
console.log( round(-5.015, 2) );  // -5.01 wrong

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

/**
 * MidpointRounding away from zero ('arithmetic' rounding)
 * Uses a half-epsilon for correction. (This offsets IEEE-754
 * half-to-even rounding that was applied at the edge cases).
 */

function RoundCorrect(num, precision = 2) {
	// half epsilon to correct edge cases.
	var c = 0.5 * Number.EPSILON * num;
//	var p = Math.pow(10, precision); //slow
	var p = 1; while (precision--> 0) p *= 10;
	if (num < 0)
		p *= -1;
	return Math.round((num   c) * p) / p;
}

// testing some edge cases
console.log(RoundCorrect(1.005, 2));  // 1.01 correct
console.log(RoundCorrect(2.175, 2));  // 2.18 correct
console.log(RoundCorrect(5.015, 2));  // 5.02 correct

console.log(RoundCorrect(-1.005, 2));  // -1.01 correct
console.log(RoundCorrect(-2.175, 2));  // -2.18 correct
console.log(RoundCorrect(-5.015, 2));  // -5.02 correct

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

Math.round(num * 1e2) / 1e2

Если вы уже используете библиотеку d3, у них есть мощная библиотека форматирования чисел: https://github.com/mbostock/d3/wiki/Formatting

Округление, в частности, находится здесь: атрибут https://github.com/mbostock/ d3 / wiki / Форматирование # d3_round

В вашем случае ответ таков:

> d3.round(1.777777, 2)
1.78
> d3.round(1.7, 2)
1.7
> d3.round(1, 2)
1

Один из способов добиться такого округления только в случае необходимости вырожденный код. НЕ ИСПОЛЬЗУЙТЕ. Number.prototype.toLocaleString () :

myNumber.toLocaleString('en', {maximumFractionDigits:2, useGrouping:false})

в IE вы можете использовать значок

Понравилась статья? Поделиться с друзьями:
JavaScript & TypeScript
Adblock
detector