Elettracompany.com

Компьютерный справочник
4 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Javascript round to 2 digits

Методы округления чисел в JavaScript

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

Для чего округлять числа?

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

На практике это не будет иметь никакого значения, поскольку речь идет о погрешности в 2 квинтилионные. Но это может отразиться на результате при работе с числами, которые представляют значения валют, процентов или размер файла. Поэтому нужно сделать JavaScript округление до целого или до определенного знака после запятой.

Округление десятичных чисел

Чтобы « обрезать » десятичное число, используются методы toFixed() или toPrecision() . Они оба принимают один аргумент, который определяет количество значимых и знаков после запятой, которые должны быть включены в результат:

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

И toFixed() , и toPrecision возвращают округленное строчное представление результата, а не число. Это означает, что прибавление rounded к randNum в результате даст конкатенацию строк, а не одно число:

Если нужно получить в результате JavaScript округления до сотых число, используйте parseFloat() :

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

Обратите внимание, что если в числе больше знаков, чем задано параметром точности, toPrecision будет выдавать результат в научном формате:

Как избежать ошибок при округлении десятичных дробей

В некоторых случаях toFixed и toPrecision осуществляют JavaScript округление 5 в меньшую сторону , а не до большего:

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

Если нужно еще более надежное решение, чем округление, оно доступно на MDN .

Округление с помощью эпсилона

Альтернативный метод JavaScript округления до десятых был введен в ES6 ( также известном, как JavaScript 2015 ). « Машинный эпсилон » обеспечивает разумный предел погрешности при сравнении двух чисел с плавающей запятой. Без округления, сравнения могут дать результаты, подобные следующим:

Math.EPSILON может быть использован в функции для получения корректного сравнения:

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

Все современные браузеры поддерживают математические функции ES6 . Но если необходимо обеспечить поддержку в старых браузерах, то нужно использовать полифиллы .

Усечение десятичных чисел

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

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

Округление до ближайшего числа

Чтобы осуществить JavaScript округление до целого , используется Math.round() :

Обратите внимание, что « половинные значения «, такие как .5 , округляются вверх.

Округление вниз до ближайшего целого числа

Если вы хотите округлять в меньшую сторону, используйте метод Math.floor() :

Округление « вниз » имеет одно направление для всех чисел, в том числе и для отрицательных. Это можно представить, как небоскреб с бесконечным количеством этажей, в том числе и ниже уровня фундамента ( представляющих отрицательные числа ). Если вы находитесь в лифте между подвальными этажами 2 и 3 ( что соответствует значению -2.5 ), Math.floor доставит вас на этаж -3 :

Если нужно избежать этого, используйте JavaScript Math округление с помощью Math.trunc() , поддерживаемый во всех современных браузерах ( кроме IE / Edge ):

MDN также предоставляет полифилл из трех строк для обеспечения поддержки Math.trunc в старых браузерах и IE / Edge .

Округление вверх до ближайшего целого числа

Если вы хотите округлить десятичные числа вверх, используйте Math.ceil . Действие этого метода также можно представить, как бесконечный лифт: Math.ceil всегда везет вас « вверх «, независимо от того, является ли число отрицательным или положительным:

Округление до ближайшего кратного числа

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

Если нужно выполнить JavaScript округление до двух знаков, можно передавать функции, как начальное число, так и кратность:

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

Чтобы округлять значения только в большую или меньшую сторону замените в функции round на ceil или floor .

Привязка к диапазону

Иногда нужно получить значение х , которое должно находиться в пределах определенного диапазона. Например, нужно значение от 1 до 100 , но мы получаем значение 123 . Чтобы исправить это, можно использовать min() ( возвращает наименьшее из чисел ) и max ( возвращает максимально допустимое число ).

Можно создать функцию или расширение класса Number :

Округление по Гауссу

Округление по Гауссу (« банковское «, конвергентное или голландское ) представляет собой метод округления без статистической погрешности. Стандартное JavaScript округление иногда дает погрешности в большую сторону. Округление по Гауссу позволяет избежать этой погрешности с помощью округления до ближайшего четного числа. Лучшее решение, которое мне известно:

Десятичные числа в CSS

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

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

Данная публикация представляет собой перевод статьи « JavaScript Rounding Recipes » , подготовленной дружной командой проекта Интернет-технологии.ру

JavaScript math, округление до двух знаков после запятой [дубликат]

этот вопрос уже есть ответ здесь:

  • Круглый до 2 знаков после запятой (только при необходимости) 59 ответов
Читать еще:  Как посмотреть ошибки

У меня есть ниже синтаксис JavaScript:

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

13 ответов:

Примечание — см редактировать 4, если 3-значная точность важна

toFixed округлит вверх или вниз для вас в зависимости от значений за 2 десятичными знаками.

Edit — а это преобразует результат в строку. Чтобы избежать этого:

Изменить 2— Как также упоминалось в комментариях, эта функция не работает с некоторой точностью, например, в случае 1.005 она вернет 1.00 вместо 1.01. Если точность до такой степени важна, я нашел этот ответ:https://stackoverflow.com/a/32605063/1726511 который, кажется, хорошо работает со всеми тестами, которые я пробовал.

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

редактировать 3 — кажется, что фиксация на фактическом возврате все еще завинчивает некоторые цифры, это окончательное редактирование, похоже, работает. Блин так много переделок!

изменить 4 — вы парни убивают меня. Edit 3 терпит неудачу на отрицательных числах, не вникая в то, почему просто легче иметь дело с превращением отрицательного числа в положительное, прежде чем делать округление, а затем поворачивать его обратно, прежде чем возвращать результат.

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

функции математика.круглый и. toFixed() предназначен для округления до ближайшего целого числа. Вы получите неверные результаты при работе с десятичными числами и использовании метода «умножение и деление» для математики.round () или параметр for .toFixed(). Например, если вы попытаетесь округлить 1.005 с помощью математики.раунд (1.005 * 100) / 100, то вы получите результат 1, и 1.00 с помощью .toFixed(2) вместо получения правильного ответа 1.01.

вы можете использовать следующее, чтобы решить эту проблему вопрос:

добавить .toFixed(2), чтобы получить два десятичных знака, которые вы хотели.

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

Алтернативной

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

и использовать его как это:

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

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

попробуйте использовать discount.toFixed(2);

лучшее и простое решение, которое я нашел это

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

или простой javascript:

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

редактировать: Я только что обнаружил то, что кажется ошибкой в Firefox 35.0.1, а это значит, что вышеизложенное может дать NaN с некоторыми значениями.
Я изменил свой код на

JavaScript math, round to two decimal places [duplicate]

Posted by: admin November 13, 2017 Leave a comment

This question already has an answer here:

NOTE – See Edit 4 if 3 digit precision is important

toFixed will round up or down for you depending on the values beyond 2 decimals.

Edit – As mentioned by others this converts the result to a string. To avoid this:

Edit 2– As also mentioned in the comments this function fails in some precision, in the case of 1.005 for example it will return 1.00 instead of 1.01. If accuracy to this degree is important I’ve found this answer: https://stackoverflow.com/a/32605063/1726511 Which seems to work well with all the tests I’ve tried.

There is one minor modification required though, the function in the answer linked above returns whole numbers when it rounds to one, so for example 99.004 will return 99 instead of 99.00 which isn’t ideal for displaying prices.

Edit 3 – Seems having the toFixed on the actual return was STILL screwing up some numbers, this final edit appears to work. Geez so many reworks!

Edit 4 – You guys are killing me. Edit 3 fails on negative numbers, without digging into why it’s just easier to deal with turning a negative number positive before doing the rounding, then turning it back before returning the result.

If you use a unary plus to convert a string to a number as documented on MDN.

For example: +discount.toFixed(2)

The functions Math.round() and .toFixed() is meant to round to the nearest integer and you may get some unwanted errors when dealing with decimals, and using the “multiply and divide” method for Math.round() or parameter for .toFixed(). For example, if you try to round 1.005 using Math.round(1.005 * 100) / 100 then you’ll get the result of 1, and 1.00 using .toFixed(2) instead of getting the correct answer of 1.01.

You can use following to solve this issue:

Add .toFixed(2) to get the two decimal places you wanted.

You could make a function that will handle the rounding for you:

Alternativ

You can add a round function to Number using prototype. I would not suggest adding .toFixed() here as it would return a string instead of number.

and use it like this:

To get the result with two decimals, you can do like this :

The value to be rounded is multiplied by 100 to keep the first two digits, then we divide by 100 to get the actual result.

Читать еще:  Java jdk 9

try using discount.toFixed(2);

A small variation on the accepted answer.
toFixed(2) returns a string, and you will always get two decimal places. These might be zeros. If you would like to suppress final zero(s), simply do this:

Edited:
I’ve just discovered what seems to be a bug in Firefox 35.0.1, which means that the above may give NaN with some values.
I’ve changed my code to

This gives a number with up to two decimal places. If you wanted three, you would multiply and divide by 1000, and so on.
The OP wants two decimal places always, but if toFixed() is broken in Firefox it needs fixing first.
See https://bugzilla.mozilla.org/show_bug.cgi?id=1134388

Fastest Way – faster than toFixed():

TWO DECIMALS

THREE DECIMALS

The best and simple solution I found is

I think the best way I’ve seen it done is multiplying by 10 to the power of the number of digits, then doing a Math.round, then finally dividing by 10 to the power of digits. Here is a simple function I use in typescript:

Or plain javascript:

To handle rounding to any number of decimal places, a function with 2 lines of code will suffice for most needs. Here’s some sample code to play with.

Numbers

In modern JavaScript, there are two types of numbers:

Regular numbers in JavaScript are stored in 64-bit format IEEE-754, also known as “double precision floating point numbers”. These are numbers that we’re using most of the time, and we’ll talk about them in this chapter.

BigInt numbers, to represent integers of arbitrary length. They are sometimes needed, because a regular number can’t exceed 2 53 or be less than -2 53 . As bigints are used in few special areas, we devote them a special chapter BigInt.

So here we’ll talk about regular numbers. Let’s expand our knowledge of them.

More ways to write a number

Imagine we need to write 1 billion. The obvious way is:

But in real life, we usually avoid writing a long string of zeroes as it’s easy to mistype. Also, we are lazy. We will usually write something like «1bn» for a billion or «7.3bn» for 7 billion 300 million. The same is true for most large numbers.

In JavaScript, we shorten a number by appending the letter «e» to the number and specifying the zeroes count:

In other words, «e» multiplies the number by 1 with the given zeroes count.

Now let’s write something very small. Say, 1 microsecond (one millionth of a second):

Just like before, using «e» can help. If we’d like to avoid writing the zeroes explicitly, we could say the same as:

If we count the zeroes in 0.000001 , there are 6 of them. So naturally it’s 1e-6 .

In other words, a negative number after «e» means a division by 1 with the given number of zeroes:

Hex, binary and octal numbers

Hexadecimal numbers are widely used in JavaScript to represent colors, encode characters, and for many other things. So naturally, there exists a shorter way to write them: 0x and then the number.

Binary and octal numeral systems are rarely used, but also supported using the 0b and 0o prefixes:

There are only 3 numeral systems with such support. For other numeral systems, we should use the function parseInt (which we will see later in this chapter).

toString(base)

The method num.toString(base) returns a string representation of num in the numeral system with the given base .

The base can vary from 2 to 36 . By default it’s 10 .

Common use cases for this are:

base=16 is used for hex colors, character encodings etc, digits can be 0..9 or A..F .

base=2 is mostly for debugging bitwise operations, digits can be 0 or 1 .

base=36 is the maximum, digits can be 0..9 or A..Z . The whole latin alphabet is used to represent a number. A funny, but useful case for 36 is when we need to turn a long numeric identifier into something shorter, for example to make a short url. Can simply represent it in the numeral system with base 36 :

Please note that two dots in 123456..toString(36) is not a typo. If we want to call a method directly on a number, like toString in the example above, then we need to place two dots .. after it.

If we placed a single dot: 123456.toString(36) , then there would be an error, because JavaScript syntax implies the decimal part after the first dot. And if we place one more dot, then JavaScript knows that the decimal part is empty and now goes the method.

Also could write (123456).toString(36) .

Rounding

One of the most used operations when working with numbers is rounding.

There are several built-in functions for rounding:

Math.floor Rounds down: 3.1 becomes 3 , and -1.1 becomes -2 . Math.ceil Rounds up: 3.1 becomes 4 , and -1.1 becomes -1 . Math.round Rounds to the nearest integer: 3.1 becomes 3 , 3.6 becomes 4 and -1.1 becomes -1 . Math.trunc (not supported by Internet Explorer) Removes anything after the decimal point without rounding: 3.1 becomes 3 , -1.1 becomes -1 .

Here’s the table to summarize the differences between them:

These functions cover all of the possible ways to deal with the decimal part of a number. But what if we’d like to round the number to n-th digit after the decimal?

For instance, we have 1.2345 and want to round it to 2 digits, getting only 1.23 .

Читать еще:  Поиск ошибок в словах

There are two ways to do so:

For example, to round the number to the 2nd digit after the decimal, we can multiply the number by 100 , call the rounding function and then divide it back.

The method toFixed(n) rounds the number to n digits after the point and returns a string representation of the result.

This rounds up or down to the nearest value, similar to Math.round :

Please note that result of toFixed is a string. If the decimal part is shorter than required, zeroes are appended to the end:

We can convert it to a number using the unary plus or a Number() call: +num.toFixed(5) .

Imprecise calculations

Internally, a number is represented in 64-bit format IEEE-754, so there are exactly 64 bits to store a number: 52 of them are used to store the digits, 11 of them store the position of the decimal point (they are zero for integer numbers), and 1 bit is for the sign.

If a number is too big, it would overflow the 64-bit storage, potentially giving an infinity:

What may be a little less obvious, but happens quite often, is the loss of precision.

Consider this (falsy!) test:

That’s right, if we check whether the sum of 0.1 and 0.2 is 0.3 , we get false .

Strange! What is it then if not 0.3 ?

Ouch! There are more consequences than an incorrect comparison here. Imagine you’re making an e-shopping site and the visitor puts $0.10 and $0.20 goods into their cart. The order total will be $0.30000000000000004 . That would surprise anyone.

But why does this happen?

A number is stored in memory in its binary form, a sequence of bits – ones and zeroes. But fractions like 0.1 , 0.2 that look simple in the decimal numeric system are actually unending fractions in their binary form.

In other words, what is 0.1 ? It is one divided by ten 1/10 , one-tenth. In decimal numeral system such numbers are easily representable. Compare it to one-third: 1/3 . It becomes an endless fraction 0.33333(3) .

So, division by powers 10 is guaranteed to work well in the decimal system, but division by 3 is not. For the same reason, in the binary numeral system, the division by powers of 2 is guaranteed to work, but 1/10 becomes an endless binary fraction.

There’s just no way to store exactly 0.1 or exactly 0.2 using the binary system, just like there is no way to store one-third as a decimal fraction.

The numeric format IEEE-754 solves this by rounding to the nearest possible number. These rounding rules normally don’t allow us to see that “tiny precision loss”, but it exists.

Округление до 2-х знаков в дробной части

До 2-х знаков в дробной части округление
Как в JS округлить число до 2-х знаков после запятой? Спасибо.

Вывести набор символов, изображающих первые N цифр дробной части вещественного числа
1)Дана строка S, изображающая вещественное число в формате с плавающей точкой, и целое число N (>.

Сортировка массива по дробной части
Здравствуйте всем! Пытаюсь вывести массив в порядке возрастания их дробной части. выводит.

Округление константы (более 15 знаков в дробной части)
Здравствуйте, уважаемые форумчане! Решаю несложную задачу, но возникают некоторые проблемы. Есть.

не знаю как в JS, но матаппарат такой:

x — любое число, m — мантисса, p — порядок в экспоненциальном представлении. m = 0, 1 = 0, p — целое число.

Это справедливо для любых действительных чисел x.

Это общий случай.

Но есть еще проще: выдели дробную часть. Умнож на 100. Округли. Раздели на 100. Сложи целую часть округляемого числа и только что полученное частное.

avastor, а чем вас не устраивает метод numObj.toFixed ([fractionDigits]) ?

Товарищей из 2003 года я понимаю — тогда этого метода в Javasript’e ещё не было.
Но сейчас-то зачем огород городить?

Добавлено через 3 минуты
И еще есть жалобы на IE с этим методом
http://javascript.ru/Number/toFixed#comment-6102
достоверность не проверял.

Добавлено через 5 минут
И поповоду 2003 года

Если посмотреть здесь
http://www.w3schools.com/jsref/jsref_tofixed.asp
Этот чудо метод, был введен в
JavaScript Version: 1.5
И посмотреть здесь
http://ru.wikipedia.org/wiki/JavaScript
пункт Версии
***
1.5 (Netscape 6.0, ноябрь 2000; также поздние версии Netscape и Mozilla
Редакция 3 (декабрь 1999). Совместим с третьей редакцией спецификации ECMA-262.
***
То есть ребятам в 2003 году, была уже доступна версия 1.5 и этот метод

Добавлено через 11 минут
P.S. Хотя если человеку нужно было округления, то указанным вами метод вполне подходит, если округлять не нужно, а просто вернуть с количеством знаков после запятой, то мой метод

avastor, заголовок темы перечитайте. Она называется ОКРУГЛЕНИЕ.
Ваш же скрипт производит ОТСЕКАНИЕ.

Что есть «округление» — можете узнать здесь.
——

Ребята по вашей первой ссылке — http://javascript.ru/Number/toFixed#comment-6102 — также, как и вы, тоже не знают про эту математическую операцию, потому и жалуются.
——

В 2003 году самым популярным был браузер Microsoft Internet Explorer 5.0, в котором работала версия Microsoft JScript 5.0 (не путать с JavaScript — у Майкрософта всё своё).
И этого метода в версии JScript 5.0 не было.
Он появился только начиная с версии JScript 5.5 и в браузере Microsoft Internet Explorer 5.5 (с июля 2001 года).
И этот браузер очень многие себе в те времена не ставили, ибо был он очень тормозным и глючным, и — главное — занимал много места на жёстком диске (а место тогда ценилось, ибо винчестеры были ещё очень дорогими).

Ссылка на основную публикацию
Adblock
detector