Округление чисел в js

Содержание:

Великий и могучий Math
JavaScript
Способы записи числа
Великий и могучий Math
Неточные вычисления
Truncating numbers in Javascript #
- TLTR (too long to read)
Форматирование чисел
Правила округления
Особенность деления на 0 в js
Важные заметки о числах
JavaScript-математика, округление до двух знаков после запятой (9)
Важные заметки о числах
Еще немного методов
- toFixed ()
- toPrecision ()
parseInt и parseFloat
Целая и дробная часть числа
- Делится ли число нацело

Великий и могучий Math

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

На других платформах существуют аналогии Math. Например, в таких популярных языках, как Java и C#, Math представляет собой класс, который поддерживает все те же стандартные функции. Так что как видите этот инструмент действительно великий и могучий.

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

Math.floor ()

Начну с Math.
floor

Обратите внимание на наименование метода. Логически становится понятно, что раз речь идет об округлении, а дословный перевод слова «floor» означает «пол», то данный инструмент округлит обрабатываемые значения в меньшую строну

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

в ответе будет число 4.

Math.ceil ()

Опять-таки посмотрите на название (в такой способ материал быстрее усваивается). Если кто-то не знает, то «ceil» означает «потолок». Значит округление числовых данных будет осуществляться в большую сторону, используя нестрогое неравенство (>=).

Как вы уже догадались, в ответе будет число 5.

Math.round ()

Данный метод округляет дробное число до ближайшего целого. Так, если дробная часть находится в диапазоне от 0 и до 0.5 не включительно, то округление происходит к меньшему значению. А если дробная часть находится в диапазоне от включительно 0.5 и до следующего целого числа, то она округляется к большему целому.

Надеюсь, все подумали или сказали правильный ответ – 5.

JavaScript

Округление чисел в excel в большую и меньшую сторону

JS Array
concat()
constructor
copyWithin()
entries()
every()
fill()
filter()
find()
findIndex()
forEach()
from()
includes()
indexOf()
isArray()
join()
keys()
length
lastIndexOf()
map()
pop()
prototype
push()
reduce()
reduceRight()
reverse()
shift()
slice()
some()
sort()
splice()
toString()
unshift()
valueOf()

JS Boolean
constructor
prototype
toString()
valueOf()

JS Classes
constructor()
extends
static
super

JS Date
constructor
getDate()
getDay()
getFullYear()
getHours()
getMilliseconds()
getMinutes()
getMonth()
getSeconds()
getTime()
getTimezoneOffset()
getUTCDate()
getUTCDay()
getUTCFullYear()
getUTCHours()
getUTCMilliseconds()
getUTCMinutes()
getUTCMonth()
getUTCSeconds()
now()
parse()
prototype
setDate()
setFullYear()
setHours()
setMilliseconds()
setMinutes()
setMonth()
setSeconds()
setTime()
setUTCDate()
setUTCFullYear()
setUTCHours()
setUTCMilliseconds()
setUTCMinutes()
setUTCMonth()
setUTCSeconds()
toDateString()
toISOString()
toJSON()
toLocaleDateString()
toLocaleTimeString()
toLocaleString()
toString()
toTimeString()
toUTCString()
UTC()
valueOf()

JS Error
name
message

JS Global
decodeURI()
decodeURIComponent()
encodeURI()
encodeURIComponent()
escape()
eval()
Infinity
isFinite()
isNaN()
NaN
Number()
parseFloat()
parseInt()
String()
undefined
unescape()

JS JSON
parse()
stringify()

JS Math
abs()
acos()
acosh()
asin()
asinh()
atan()
atan2()
atanh()
cbrt()
ceil()
clz32()
cos()
cosh()
E
exp()
expm1()
floor()
fround()
LN2
LN10
log()
log10()
log1p()
log2()
LOG2E
LOG10E
max()
min()
PI
pow()
random()
round()
sign()
sin()
sqrt()
SQRT1_2
SQRT2
tan()
tanh()
trunc()

JS Number
constructor
isFinite()
isInteger()
isNaN()
isSafeInteger()
MAX_VALUE
MIN_VALUE
NEGATIVE_INFINITY
NaN
POSITIVE_INFINITY
prototype
toExponential()
toFixed()
toLocaleString()
toPrecision()
toString()
valueOf()

JS OperatorsJS RegExp
constructor
compile()
exec()
g
global
i
ignoreCase
lastIndex
m
multiline
n+
n*
n?
n{X}
n{X,Y}
n{X,}
n$
^n
?=n
?!n
source
test()
toString()

(x|y)
.
\w
\W
\d
\D
\s
\S
\b
\B
\0
\n
\f
\r
\t
\v
\xxx
\xdd
\uxxxx

JS Statements
break
class
continue
debugger
do…while
for
for…in
for…of
function
if…else
return
switch
throw
try…catch
var
while

JS String
charAt()
charCodeAt()
concat()
constructor
endsWith()
fromCharCode()
includes()
indexOf()
lastIndexOf()
length
localeCompare()
match()
prototype
repeat()
replace()
search()
slice()
split()
startsWith()
substr()
substring()
toLocaleLowerCase()
toLocaleUpperCase()
toLowerCase()
toString()
toUpperCase()
trim()
valueOf()

Способы записи числа

Округление в excel

Представьте, что нам надо записать число 1 миллиард. Самый очевидный путь:

Но в реальной жизни мы обычно опускаем запись множества нулей, так как можно легко ошибиться. Укороченная запись может выглядеть как или для 7 миллиардов 300 миллионов. Такой принцип работает для всех больших чисел.

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

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

Сейчас давайте запишем что-нибудь очень маленькое. К примеру, 1 микросекунду (одна миллионная секунды):

Записать микросекунду в укороченном виде нам поможет .

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

Другими словами, отрицательное число после подразумевает деление на 1 с указанным количеством нулей:

Шестнадцатеричные числа широко используются в JavaScript для представления цветов, кодировки символов и многого другого. Естественно, есть короткий стиль записи: , после которого указывается число.

Например:

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

Есть только 3 системы счисления с такой поддержкой. Для других систем счисления мы рекомендуем использовать функцию (рассмотрим позже в этой главе).

Великий и могучий Math

Генератор случайных чисел эксель

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

Math.floor ()

Начну с Math.floor

Также возможен вариант, когда обработанное число с помощью этой функции осталось прежним. Все потому, что округление осуществляется по нестрогому неравенству (<=). Таким образом, при отработке этой строчки кода:

в ответе будет число 4.

Math.ceil ()

Как вы уже догадались, в ответе будет число 5.

Math.round ()

Надеюсь, все подумали или сказали правильный ответ – 5.

Неточные вычисления

Внутри JavaScript число представлено в виде 64-битного формата IEEE-754. Для хранения числа используется 64 бита: 52 из них используется для хранения цифр, 11 из них для хранения положения десятичной точки (если число целое, то хранится 0), и один бит отведён на хранение знака.

Если число слишком большое, оно переполнит 64-битное хранилище, JavaScript вернёт бесконечность:

Наиболее часто встречающаяся ошибка при работе с числами в JavaScript – это потеря точности.

Посмотрите на это (неверное!) сравнение:

Да-да, сумма и не равна .

Странно! Что тогда, если не ?

Но почему это происходит?

Число хранится в памяти в бинарной форме, как последовательность бит – единиц и нулей. Но дроби, такие как , , которые выглядят довольно просто в десятичной системе счисления, на самом деле являются бесконечной дробью в двоичной форме.

Другими словами, что такое ? Это единица делённая на десять — , одна десятая. В десятичной системе счисления такие числа легко представимы, по сравнению с одной третьей: , которая становится бесконечной дробью .

Деление на гарантированно хорошо работает в десятичной системе, но деление на – нет. По той же причине и в двоичной системе счисления, деление на обязательно сработает, а становится бесконечной дробью.

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

Числовой формат IEEE-754 решает эту проблему путём округления до ближайшего возможного числа. Правила округления обычно не позволяют нам увидеть эту «крошечную потерю точности», но она существует.

Пример:

И когда мы суммируем 2 числа, их «неточности» тоже суммируются.

Вот почему – это не совсем .

Не только в JavaScript

Справедливости ради заметим, что ошибка в точности вычислений для чисел с плавающей точкой сохраняется в любом другом языке, где используется формат IEEE 754, включая PHP, Java, C, Perl, Ruby.

Можно ли обойти проблему? Конечно, наиболее надёжный способ — это округлить результат используя метод toFixed(n):

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

Таким образом, метод умножения/деления уменьшает погрешность, но полностью её не решает.

Забавный пример

Попробуйте выполнить его:

Причина та же – потеря точности. Из 64 бит, отведённых на число, сами цифры числа занимают до 52 бит, остальные 11 бит хранят позицию десятичной точки и один бит – знак. Так что если 52 бит не хватает на цифры, то при записи пропадут младшие разряды.

Интерпретатор не выдаст ошибку, но в результате получится «не совсем то число», что мы и видим в примере выше. Как говорится: «как смог, так записал».

Два нуля

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

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

В большинстве случаев это поведение незаметно, так как операторы в JavaScript воспринимают их одинаковыми.

Truncating numbers in Javascript #

simply removes all the fractional digits. It takes one argument which is a number. If the argument is a positive number it behaves exactly the same as . For negative numbers it does the same job as .

It’s worth mentioning that the browser support for isn’t great. It is part of new . Have a look at the browser support list:

Google Chrome >= 38
Firefox >= 25
Internet Explorer >= Nope 🙁
Opera >= 25
Safari >= 7.1

Luckily there is a way to use this without ES6 support (thanks to Johny who suggested this solution in comments below). We can use bitwise operators to accomplish this task. Unfortunately there are some restriction as well. All bitwise operations work on signed 32-bit integers. Using them converts a float to an integer. In practice it means that we can safely work up to (2 147 483 647) which is much less than (1.7976931348623157e+308). This isn’t a great idea for monetary calculations either.

TLTR (too long to read)

I know, I know — time is money. Lets sum it up.

— rounds to the nearest integer
— rounds down towards negative infinity
— rounds up towards positive infinity
— rounds up or down towards zero (bad browsers support)

Форматирование чисел

В JavaScript отформатировать вывод числа в соответствии с региональными стандартами (языковыми настройками операционной системы) позволяет метод toLocaleString() .

Например, выполним форматирование числа в соответствии с региональными стандартами, которые установлены в системе по умолчанию:

Var number = 345.46;
console.log(number.toLocaleString()); //»345,46″

Например, выполним форматирование числа в соответствии с региональными стандартами России (ru):

Console.log((108.1).toLocaleString(«ru-RU»)); //»108,1″

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

Console.log((2540.125).toLocaleString(«ru-RU»,{style:»currency», currency:»RUB»})); //»2 540,13 ₽»
console.log((89.3).toLocaleString(«ru-RU»,{style:»currency», currency:»USD»})); //»89,30 $»
console.log((2301.99).toLocaleString(«ru-RU»,{style:»currency», currency:»EUR»})); //»2 301,99 €»

Представление числа в виде процентов:

Console.log((0.45).toLocaleString(«ru-RU»,{style:»percent»})); //»45 %»

Разбить число на разряды (свойство useGrouping):

Console.log((125452.32).toLocaleString(«ru-RU»,{useGrouping:true})); //»125 452,32″

Вывести с число с определённым количеством цифр (2) после запятой:

Console.log((1240.4564).toLocaleString(«ru-RU»,{minimumFractionDigits:2, maximumFractionDigits:2})); //»1 240,46″

Правила округления

Коммерческое округление

В Коммерческие туры (не отрицательные числа) выглядит следующим образом :

Если число в первом десятичном разряде равно 0, 1, 2, 3 или 4, оно округляется в меньшую сторону.
Если число в первом десятичном разряде — 5, 6, 7, 8 или 9, то оно округляется в большую сторону.

Это правило округления описано в стандарте DIN 1333 . Округление часто уже преподается в начальной школе.

Примеры (округление до двух знаков после запятой):

13,3749 … € ≈ 13,37 €
13,3750 … € ≈ 13,38 €

Отрицательные числа в зависимости от их величины округлой формы, на 5 , чтобы сказать от нуля ( Engl : от нуля ):

−13,3749 … € ≈ −13,37 €
−13,3750 … € ≈ −13,38 €

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

Симметричное закругление

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

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

Если число в первом десятичном разряде равно 0, 1, 2, 3 или 4, оно округляется в меньшую сторону.
Если цифра 5 (за которой следуют другие цифры, которые не все равны нулю), 6, 7, 8 или 9 в первом десятичном разряде, она округляется в большую сторону.
Если число в первом десятичном разряде — только 5 (или 5, за которой следуют только нули), оно округляется таким образом, чтобы последнее сохраняемое число было четным («правило четных чисел»).

Этот тип округления используется в числовой математике , инженерии и технике. Он предусмотрен стандартом IEEE 754 для вычислений с двоичными числами с плавающей запятой в компьютерах. В англоязычной литературе это называется Round to Even или Banker’s Rounding .

Примеры (округление до одного десятичного знака):

2,2499 ≈ 2,2 (по правилу 1)
2,2501 ≈ 2,3 (по правилу 2)
2,2500 ≈ 2,2 (округлено до четного числа согласно правилу 3)
2,3500 ≈ 2,4 (округлено до четного числа согласно правилу 3)

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

Округление с сохранением суммы

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

Важными приложениями являются пропорциональное распределение мест и распределение всего НДС в счете-фактуре по его отдельным позициям.

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

Метод Хара-Нимейера может быть обобщен для слагаемых с обоими знаками : вы округляете все числа до ближайших круглых чисел, и пока сумма слишком велика (или слишком мала), вы выбираете одно из округленных (или округленных) чисел. ) нумерует с наибольшим округление (или самое большое количество округления вниз) и изменяет его округления в направлении , противоположном. Это означает, что сумма сумм изменений минимальна .

Особенность деления на 0 в js

Как известно из уроков по математике, делить на нуль нельзя. Это правило взяли за основу большинство создателей языков программирования. Поэтому при делении на нуль все программы выдают ошибку.

Однако JavaScript отличился и здесь. Так, во время выполнения такой операции никаких сообщений о баге не возникает…потому что такая операция возвращает «Infinity»!

Почему же так? Как известно из тех же математических наук, чем меньше делитель, тем в результате получается большее число. Именно поэтому создатели данного прототипно-ориентированного языка решили отказаться от шаблонов и пойти своим путем.

Для тех, кто впервые сталкивается со значением Infinity, ниже я объяснил его особенности.

Может быть отрицательной. Также сохраняются все стандартные правила работы с арифметическими операторами.

На этом, пожалуй, и закончу. Если вам понравилась публикация, то обязательно подписывайтесь на мой блог. Не жадничайте ссылкой на интересные статьи и делитесь ими с друзьями. Пока-пока!

Прочитано: 620 раз

Важные заметки о числах

Для начала запомните, что в js все виды чисел (дробные и целые) относятся к типу Number
. К тому же все они 64-битные, так как хранятся в формате «double precision», который также известен под стандартом IEEE-754.

Создаются численные переменные привычным способом:

Поддерживает и другие числовые представления. Так, еще можно создавать числа с плавающей точкой (их еще иногда называют «числа в научном формате»).

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

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

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

JavaScript-математика, округление до двух знаков после запятой (9)

У меня есть следующий синтаксис JavaScript:

Var discount = Math.round(100 — (price / listprice) * 100);

Это округляется до целого числа. Как я могу вернуть результат с двумя десятичными знаками?

Вот рабочий пример

Var value=200.2365455;
result=Math.round(value*100)/100 //result will be 200.24

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

Var testNum = 134.9567654;
var decPl = 2;
var testRes = roundDec(testNum,decPl);
alert (testNum + » rounded to » + decPl + » decimal places is » + testRes);
function roundDec(nbr,dec_places){
var mult = Math.pow(10,dec_places);
return Math.round(nbr * mult) / mult;
}

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

Function round(value, decimals) {
return Number(Math.round(value+»e»+decimals)+»e-«+decimals);
}
round(1.005, 2); // 1.01

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

Var discount = + ((price / listprice).toFixed(2));

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

Var discount = Math.round(price / listprice * 100) / 100;

Это дает число с точностью до двух знаков после запятой. Если вам нужно три, вы будете умножать и делить на 1000, и так далее. OP хочет два десятичных разряда всегда, но если toFixed () нарушено в Firefox, сначала нужно зафиксировать его. См. https://bugzilla.mozilla.org/show_bug.cgi?id=1134388

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

Var discount = Math.round((100 — (price / listprice) * 100) * 100) / 100;

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

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

Function roundToXDigits(value: number, digits: number) {
value = value * Math.pow(10, digits);
value = Math.round(value);
value = value / Math.pow(10, digits);
return value;
}

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

Function roundToXDigits(value, digits) {
if(!digits){
digits = 2;
}
value = value * Math.pow(10, digits);
value = Math.round(value);
value = value / Math.pow(10, digits);
return value;
}

ПРИМЕЧАНИЕ. — См. Редактировать 4, если важна 3-значная точность.

Var discount = (price / listprice).toFixed(2);

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

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

Var discount = +((price / listprice).toFixed(2));

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

Edit 3
— Кажется, что toFixed на фактическом возврате STILL закручивал некоторые цифры, это окончательное редактирование, похоже, работает. Geez так много репараций!

Var discount = roundTo((price / listprice), 2);
function roundTo(n, digits) {
if (digits === undefined) {
digits = 0;
}
var multiplicator = Math.pow(10, digits);
n = parseFloat((n * multiplicator).toFixed(11));
var test =(Math.round(n) / multiplicator);
return +(test.toFixed(digits));
}

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

Function roundTo(n, digits) {
var negative = false;
if (digits === undefined) {
digits = 0;
}
if(n

Самый быстрый путь
— быстрее, чем toFixed ():

Важные заметки о числах

Создаются численные переменные привычным способом:

Еще немного методов

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

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

toFixed ()

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

Как видно, если не указать аргумента, то toFixed ()) округлит дробное значение до целого числа. В третьей строке выполнено округление до 2-знаков, а в четвертой – из-за параметра «7» было дописано еще три 0.

toPrecision ()

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

parseInt и parseFloat

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

Единственное исключение — это пробелы в начале строки и в конце, они игнорируются.

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

Для этого есть и .

Они «читают» число из строки. Если в процессе чтения возникает ошибка, они возвращают полученное до ошибки число. Функция возвращает целое число, а возвращает число с плавающей точкой:

Функции вернут , если не смогли прочитать ни одну цифру:

Второй аргумент

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

Целая и дробная часть числа

Получить целую часть числа можно используя метод Math.floor() и parseInt() :

Console.log(Math.floor(7.21)); // 7
console.log(parseInt(7.21)); // 7

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

Console.log(7.21%1); // 0.20999999999999996
// с точностью до 2 знаков после запятой
console.log((7.21%1).toFixed(2)); // «0.21»

Кроме этого дробную часть можно получить также с помощью вычислений:

Var number = 7.21;
var fractionNumber = number — Math.floor(Math.abs(number));
console.log(fractionNumber); // 0.20999999999999996

Делится ли число нацело

Определить делится ли число нацело можно используя оператор процента:

Var number = 9;
// если остаток от деления числа number на 3 равен 0, то да, иначе нет
if (number%3==0) {
console.log («Число » + number + » делится на 3″);
} else {
console.log («Число » + number + » не делится на 3″);
}