Как сравнить только дробные части чисел js

Number.isInteger()

Метод Number.isInteger() определяет, является ли переданное значение целым числом.

Интерактивный пример

Синтаксис

Number.isInteger(value)

Параметры

Значение, проверяемое на целочисленность.

Возвращаемое значение

Boolean сообщающий о том, является ли переданное значение целочисленным числом.

Описание

Если целевое значение является целым числом, возвращает true . Если значение NaN или Infinity , то возвращает false . Метод также возвращает true , если это вещественное число с точкой, которое может быть представлено в целочисленном виде.

Примеры

.isInteger(0); // true Number.isInteger(1); // true Number.isInteger(-100000); // true Number.isInteger(99999999999999999999999); // true Number.isInteger(0.1); // false Number.isInteger(Math.PI); // false Number.isInteger(NaN); // false Number.isInteger(Infinity); // false Number.isInteger(-Infinity); // false Number.isInteger("10"); // false Number.isInteger(true); // false Number.isInteger(false); // false Number.isInteger([1]); // false Number.isInteger(5.0); // true Number.isInteger(5.000000000000001); // false Number.isInteger(5.0000000000000001); // true 

Полифил

.isInteger = Number.isInteger || function (value)  return ( typeof value === "number" && isFinite(value) && Math.floor(value) === value ); >; 

Спецификации

Specification
ECMAScript Language Specification # sec-number.isinteger

Совместимость с браузерами

BCD tables only load in the browser

Смотрите также

• Объект Number , которому принадлежит этот метод.

Found a content problem with this page?

• Edit the page on GitHub.
• Report the content issue.
• View the source on GitHub.

This page was last modified on 7 авг. 2023 г. by MDN contributors.

Your blueprint for a better internet.

MDN

Support

• Product help
• Report an issue

Our communities

Developers

• Web Technologies
• Learn Web Development
• MDN Plus
• Hacks Blog

• Website Privacy Notice
• Cookies
• Legal
• Community Participation Guidelines

Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation.
Portions of this content are ©1998– 2024 by individual mozilla.org contributors. Content available under a Creative Commons license.

Math.round()

Метод Math.round() возвращает число, округлённое к ближайшему целому.

Синтаксис

Math.round(x)

Параметры

Описание

Если дробная часть числа больше, либо равна 0,5, аргумент будет округлён до ближайшего большего целого. Если дробная часть числа меньше 0,5, аргумент будет округлён до ближайшего меньшего целого.

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

Примеры

Пример: использование метода Math.round()

// Вернёт значение 20 x = Math.round(20.49); // Вернёт значение 21 x = Math.round(20.5); // Вернёт значение -20 x = Math.round(-20.5); // Вернёт значение -21 x = Math.round(-20.51); // Вернёт значение 1 (!) // Обратите внимание на ошибку округления из-за неточности арифметики с плавающей запятой // Сравните этот результат с результатом Math.round(1.005, -2) из следующего примера x = Math.round(1.005 * 100) / 100; 

Пример: корректировка округления десятичных дробей

// Замыкание (function ()  /** * Корректировка округления десятичных дробей. * * @param type Тип корректировки. * @param value Число. * @param exp Показатель степени (десятичный логарифм основания корректировки). * @returns Скорректированное значение. */ function decimalAdjust(type, value, exp)  // Если степень не определена, либо равна нулю. if (typeof exp === "undefined" || +exp === 0)  return Math[type](value); > value = +value; exp = +exp; // Если значение не является числом, либо степень не является целым числом. if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0))  return NaN; > // Сдвиг разрядов value = value.toString().split("e"); value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp))); // Обратный сдвиг value = value.toString().split("e"); return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp)); > // Десятичное округление к ближайшему if (!Math.round10)  Math.round10 = function (value, exp)  return decimalAdjust("round", value, exp); >; > // Десятичное округление вниз if (!Math.floor10)  Math.floor10 = function (value, exp)  return decimalAdjust("floor", value, exp); >; > // Десятичное округление вверх if (!Math.ceil10)  Math.ceil10 = function (value, exp)  return decimalAdjust("ceil", value, exp); >; > >)(); // Округление к ближайшему 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 -- сравните этот результат с результатом Math.round(1.005*100)/100 выше // Округление вниз Math.floor10(55.59, -1); // 55.5 Math.floor10(59, 1); // 50 Math.floor10(-55.51, -1); // -55.6 Math.floor10(-51, 1); // -60 // Округление вверх Math.ceil10(55.51, -1); // 55.6 Math.ceil10(51, 1); // 60 Math.ceil10(-55.59, -1); // -55.5 Math.ceil10(-59, 1); // -50 

Спецификации

Specification
ECMAScript Language Specification # sec-math.round

Совместимость с браузерами

BCD tables only load in the browser

Смотрите также

• Math.abs()
• Math.ceil()
• Math.floor()
• Math.sign() Экспериментальная возможность
• Math.trunc() Экспериментальная возможность

Число

Тип данных «число» ( number ) содержит числа с плавающей точкой в диапазоне от -(2 53 − 1) до 2 53 − 1, а также специальные значения Infinity , — Infinity и NaN .

Для этого типа данных определены стандартные арифметические операции сложения + , вычитания — , умножения * , деления / , взятия остатка от целочисленного деления % , сравнения > , < , >= , < = , = = , = = = , ! = , ! = = .

В JavaScript отсутствует отдельный тип данных для целых чисел, для целых чисел также используется тип number .

Как пишется

Скопировать ссылку «Как пишется» Скопировано

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

 const int = 4const decimal = 0.101const sameDecimal = .101 const int = 4 const decimal = 0.101 const sameDecimal = .101    Скопировать Скопировано Не удалось скопировать   

Можно использовать экспоненциальную запись. Например, один миллион в экспоненциальной записи:

 const scientific = 1e6 const scientific = 1e6    Скопировать Скопировано Не удалось скопировать   

Числа так же могут быть представлены в двоичном, восьмеричном или шестнадцатеричном виде. Такие числа начинаются с приставки 0b , 0o , 0x соответственно. При выводе на экран они будут преобразованы в десятичную систему счисления:

 const binary = 0b11console.log(binary)// 3 const octal = 0o77console.log(octal)// 63 const hexadecimal = 0xFFconsole.log(hexadecimal)// 255 const binary = 0b11 console.log(binary) // 3 const octal = 0o77 console.log(octal) // 63 const hexadecimal = 0xFF console.log(hexadecimal) // 255    Скопировать Скопировано Не удалось скопировать   

Как понять

Скопировать ссылку «Как понять» Скопировано

Число с плавающей точкой

Скопировать ссылку «Число с плавающей точкой» Скопировано

Число в JavaScript представлено в виде 64-битного формата IEEE-754. Формат хранит произвольное число в виде трёх значений: 1 бит на знак числа, 52 бита значения числа и ещё 11 бит местоположения точки. С таким подходом можно эффективно хранить значения в большом диапазоне от -(2 53 − 1) до 2 53 − 1.

Из-за того, что положение точки в числе хранится отдельным значением, формат и называется числом с плавающей точкой (floating point number).

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

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

Скопировать ссылку «Неточные вычисления» Скопировано

В десятичной системе счисления есть числа, которые не могут быть записаны точно. Например, треть ¹⁄₃ записывается как бесконечная дробь 0.33(3).

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

 console.log(0.2 + 0.7)// 0.8999999999999999 console.log(0.2 + 0.7) // 0.8999999999999999    Скопировать Скопировано Не удалось скопировать   

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

Например, если ваша система работает с деньгами, то лучше хранить цены в копейках или центах. Это позволит избежать большого количества операций с дробями. Для вывода цен можно пользоваться методом to Fixed , который округлит число до указанного разряда:

 const priceInCents = 15650const discount = priceInCents * 0.33const total = (priceInCents - discount) / 100console.log(total.toFixed(2))// 104.86 const priceInCents = 15650 const discount = priceInCents * 0.33 const total = (priceInCents - discount) / 100 console.log(total.toFixed(2)) // 104.86    Скопировать Скопировано Не удалось скопировать   

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

 const small = 0.11111111111111111const smaller = 0.11111111111111110 console.log(small.toFixed(20))// 0.11111111111111110494console.log(smaller.toFixed(20))// 0.11111111111111110494console.log(small === smaller)// true const small = 0.11111111111111111 const smaller = 0.11111111111111110 console.log(small.toFixed(20)) // 0.11111111111111110494 console.log(smaller.toFixed(20)) // 0.11111111111111110494 console.log(small === smaller) // true    Скопировать Скопировано Не удалось скопировать   

Специальные значения

Скопировать ссылку «Специальные значения» Скопировано

Стандарт IEEE-754 определяет три специальных значения. Эти значения принадлежат типу number , но не работают, как обычные числа:

• бесконечность Infinity ;
• минус бесконечность — Infinity ;
• не число (not a number) NaN .

Бесконечности используются, чтобы определить результат некоторых арифметических операций. Например, деление на ноль в JavaScript вернёт бесконечность:

 console.log(5 / 0)// Infinity console.log(-3 / 0)// -Infinity console.log(5 / 0) // Infinity console.log(-3 / 0) // -Infinity    Скопировать Скопировано Не удалось скопировать   

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

 console.log(1e999)// Infinity console.log(1e999) // Infinity    Скопировать Скопировано Не удалось скопировать   

Значение NaN используется, чтобы сообщить об операции, результатом которой оказалось не число. В JavaScript существует пять операций, которые могут вернуть NaN :

• ошибка парсинга числа (например, при попытке превратить строку в число parse Int ( ‘привет’ ) ).
• результат математической операции не находится в полей действительных чисел (например, взятие корня от -1).
• один из операндов в арифметической операции — NaN ( 5 + Na N ).
• результат арифметической операции не определён для переданных операндов ( undefined + undefined ).
• арифметическая операция со строкой, кроме сложения ( ‘привет’ * 5 )

Согласно спецификации, NaN не равен самому себе. Проверить, что в переменной хранится NaN простым сравнением не получится:

 const result = NaN console.log(result === NaN)// false const result = NaN console.log(result === NaN) // false    Скопировать Скопировано Не удалось скопировать   

Для проверки на NaN пользуйтесь функцией Number . isNa N ( ) , которая возвращает true если переданное значение — NaN :

 const result = NaN console.log(Number.isNaN(result))// true const result = NaN console.log(Number.isNaN(result)) // true    Скопировать Скопировано Не удалось скопировать   

Для проверки, что значение в переменной является конечным числом, а не специальным значением, пользуйтесь функцией Number . is Finite ( ) , она возвращает true , если переданный аргумент — число.

 const inf = Infinityconst nan = NaNconst num = 99999 console.log(Number.isFinite(inf))// falseconsole.log(Number.isFinite(nan))// falseconsole.log(Number.isFinite(num))// true const inf = Infinity const nan = NaN const num = 99999 console.log(Number.isFinite(inf)) // false console.log(Number.isFinite(nan)) // false console.log(Number.isFinite(num)) // true    Скопировать Скопировано Не удалось скопировать   

Операции с числами

Скопировать ссылку «Операции с числами» Скопировано

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

 const a = 5const b = 10 console.log(-a)// -5console.log(a + b)// 15console.log(a - b)// -5console.log(a / b)// 0.5console.log(a * b)// 50 console.log((a + b) / 10)// 1.5 const a = 5 const b = 10 console.log(-a) // -5 console.log(a + b) // 15 console.log(a - b) // -5 console.log(a / b) // 0.5 console.log(a * b) // 50 console.log((a + b) / 10) // 1.5    Скопировать Скопировано Не удалось скопировать   

Существует оператор взятия остатка от деления нацело % :

 console.log(5 % 2)// 1, потому что 5 = 2 * 2 + 1console.log(5 % 3)// 2, потому что 5 = 1 * 3 + 2console.log(5 % 5)// 0, потому что 5 = 5 * 1 + 0 console.log(5 % 2) // 1, потому что 5 = 2 * 2 + 1 console.log(5 % 3) // 2, потому что 5 = 1 * 3 + 2 console.log(5 % 5) // 0, потому что 5 = 5 * 1 + 0    Скопировать Скопировано Не удалось скопировать   

Возведения в степень ** :

 console.log(2 ** 4)// 16 console.log(2 ** 4) // 16    Скопировать Скопировано Не удалось скопировать   

Для округления, взятия корней и других математических операций в JavaScript существует отдельный модуль Math .

Операторы сравнения, возвращают булевое значение:

 console.log(5 > 10)// falseconsole.log(5 >= 10)// falseconsole.log(5 < 10)// trueconsole.log(10 // trueconsole.log(5 == 10)// falseconsole.log(5 === 10)// falseconsole.log(5 != 10)// trueconsole.log(5 !== 10)// true console.log(5 > 10) // false console.log(5 >= 10) // false console.log(5  10) // true console.log(10  10) // true console.log(5 == 10) // false console.log(5 === 10) // false console.log(5 != 10) // true console.log(5 !== 10) // true    Скопировать Скопировано Не удалось скопировать   

Строгое = = = и нестрогое = = сравнение работает одинаково, когда оба сравниваемых значения имеют тип «число». В других случаях их поведение отличается.

Числовой разделитель

Скопировать ссылку «Числовой разделитель» Скопировано

В спецификации EcmaScript 2021 года (ES12) появилась возможность добавлять в числа разделители. Например:

 const number = 1_000_000_000 console.log(number)// 1000000000 const number = 1_000_000_000 console.log(number) // 1000000000    Скопировать Скопировано Не удалось скопировать   

Разделители делают большие числа более читаемыми, внешне выделяя разряды чисел.

 const integer = 1_234_567_890const float = 0.123_456_789 const integer = 1_234_567_890 const float = 0.123_456_789    Скопировать Скопировано Не удалось скопировать   

Разделители доступны для чисел других счислений и Big Int :

 const binary = 0b0101_1111_0001const hex = 0x12_AB_34_CDconst bigInt = 1_234_567_890n const binary = 0b0101_1111_0001 const hex = 0x12_AB_34_CD const bigInt = 1_234_567_890n    Скопировать Скопировано Не удалось скопировать   

Дополнительные методы

Скопировать ссылку «Дополнительные методы» Скопировано

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

 const num = 99.99 console.log(num.toFixed(1))// 100.0 const num = 99.99 console.log(num.toFixed(1)) // 100.0    Скопировать Скопировано Не удалось скопировать   

Часто используемые методы обёртки, такие как to Fixed ( ) , to String ( ) и to Locale String ( ) , описаны в отдельной статье.

На собеседовании

Скопировать ссылку «На собеседовании» Скопировано

Как проверить, что значение переменной (например, possibly Wrong Number ) не является NaN ? Предполагаем что typeof possibly Wrong Number = = = ‘number’

Скопировать ссылку «Как проверить, что значение переменной (например, possiblyWrongNumber) не является NaN? Предполагаем что typeof possiblyWrongNumber === ‘number'» Скопировано

Редакция

Скопировать ссылку «Редакция Полина Гуртовая отвечает» Скопировано

Ответ очень простой – нужно воспользоваться специальной функцией Number . is Nan ( ) . В качестве аргумента нужно передать проверяемую переменную.

Вас может запутать формулировка вопроса: typeof possibly Wrong Number = = = ‘number’ . Это же not a number, подумаете вы. Дело в том, что NaN используется для обозначения результатов вычислений, в которых «что-то пошло не так». Можете думать о NaN так: «Тут должно быть число, но вычисление сломалось». Это может произойти, если захотите вычислить квадратный корень из -1 . В результате получится комплексное число, с которым наш браузер из коробки работать не умеет.

Неправильным ответом на этот вопрос будет вот такая проверка:

 possiblyWrongNumber === NaN possiblyWrongNumber === NaN    Скопировать Скопировано Не удалось скопировать   

Однако в ней уже содержится ответ на более хитрый дополнительный вопрос:

❓ Представим себе, что функции Number . is Nan ( ) не существует. Как в таком случае проверить, что значение переменной possibly Wrong Number не является NaN ? Условие typeof possibly Wrong Number = = = ‘number’ по-прежнему выполняется.

Ответ такой: просто нужно сравнить значение переменной possibly Wrong Number с самим собой. Если они равны, значит в переменной не NaN :

 possiblyWrongNumber === possiblyWrongNumber possiblyWrongNumber === possiblyWrongNumber   Скопировать Скопировано Не удалось скопировать   

Как правильно сравнить десятичные числа в JS?

Есть ли способ сравнить decimal числа с учетом того что последнее чило у них может быть + или — 1 ?

2.000000001 == 2 // true 4.9999999998 >= 4.9999999999 // true 7.99 == 8.02 //false // Так как 7.99 равен только 7.98, 7.99, 8.00 // А 8.02 == 8.01, 8.02, 8.03

Возможно ли такое сравнение чисел в JS и как это грамотно реализовать ?

• Вопрос задан более трёх лет назад
• 1285 просмотров

2 комментария

Простой 2 комментария

Сергей Соколов @sergiks Куратор тега JavaScript
сколько цифр после запятой ожидается?
Значения приходят как числа или как строки?
Сергей Соколов, Интересно, какое это имеет значение?
Решения вопроса 4

Еда — это святое
Math.abs(x — y) <= 0.01 к примеру Ответ написан более трёх лет назад Нравится 3 2 комментария
Это не будет работать 7.98 — 7.97 может быть 0,01000000005 к примеру

Дмитрий, изначально задача поставлена с непониманием работы вещественных чисел
Кратко о себе: Я есть

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

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

const compare= (v, v2) => < const parts = String(v).split('.') const pow = parts.length >1 ? parts.pop().length : 0 return Math.round(Math.abs(v - v2) * Math.pow(10, pow)) console.log(compare(7.98, 7.99)) // true console.log(compare(7.98, 7.97)) // true console.log(compare(7.98, 8)) // false console.log(compare(0.1, 0.15)) // true

если по числу с наибольшим количеством знаков после запятой, то такой

const compare= (v, v2) => < const parts = [v, v2].map(v =>String(v).split('.')) const pow = Math.max(. parts.map(v => v.length > 1 ? v.pop().length : 0)) return Math.round(Math.abs(v - v2) * Math.pow(10, pow)) console.log(compare(7.98, 7.99)) // true console.log(compare(7.98, 7.97)) // true console.log(compare(7.98, 8)) // false console.log(compare(0.1, 0.15)) // false

Ответ написан более трёх лет назад
Нравится 2 4 комментария
Сергей Соколов @sergiks Куратор тега JavaScript
compare(0.1, 0.15) // true
а должно быть false

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

const compare= (v, v2) => < const parts = [v, v2].map(v =>String(v).split('.')) const pow = Math.max(. parts.map(v => v.length > 1 ? v.pop().length : 0)) return Math.round(Math.abs(v - v2) * Math.pow(10, pow))

Demigodd @Demigodd Автор вопроса

Дмитрий,
Спасибо за подробный ответ.
Обязательно ли избавиться от js-ных точностей ?

Просто я получаю сумму неких чисел.
И делаю toFixed(10).

Тут мне и нужно такое сравнение что бы проверить такие числа.

sum = Number(sum.toFixed(10)); total = Number(total.toFixed(10)); sum == total

Сергей Соколов @sergiks Куратор тега JavaScript

DEATH2298, надо было этот важный момент в вопросе указать!

В этой ситуации достаточно Math.abs(sum — total) т.к. тут «ошибка округления» не зависит от последней ненулевой цифры, а заранее известна: 0.0000000001

Сергей Соколов @sergiks Куратор тега JavaScript

Можно прогнать числа через .toExponential() – это их нормализует:
(123.4567).toExponential() // «1.234567e+2»
и разбить на три части: до запятой [1, 10) , после запятой и степень.
Три целых: [1, 234567, 2]

Для проверки «равенства ±1» обязательно, чтобы степень (третье число) совпала.
Разность вторых чисел — буквально вычитаем и берем Math.abs() — если равна нулю, сравниваем только первые числа — на разность не выше 1. Если первые числа равны, то разность вторых не превышать 1 должна.

С таким же преобразованием числа легко реализовать и другие операции сравнения: >= ,

const fuzzy = < split: n => < const parts = n.toExponential().split('e') .map((p, i) =>i ? parseInt(p) : p.split('.').map(x => parseInt(x))); if (parts[0].length < 2) parts[0].push(0); return [parts[0][0], parts[0][1], parts[1]]; >, eq: (a, b) => < a = fuzzy.split(a); b = fuzzy.split(b); if (a[2] !== b[2]) return false; const diff = Math.abs(a[1] - b[1]); if (diff === 0) return Math.abs(a[0] - b[0]) >

Использовать: fuzzy.eq( 12.1234, 12.1233) // true

const tests = [ [1, 1, true], [111, 112, true], [0.001, .002, true], [0.001, .0025, false], [0.001, .003, false], [12.345, 1.2345, false], [123.88, 123.870, true], [-1.11111111, 1.11111110, false], [-1.11111111, -1.11111112, true], [2.000000001, 2, true], [4.9999999998, 4.9999999999, true], [7.9, 8.02, false], [7.99, 7.98, true], [7.99, 7.99, true], [7.99, 8.00, true], // НЕ ПРОХОДИТ! Надо этот случай предусмотреть, но я ушёл спать. ]; let allok = true; tests.forEach(test => < if (fuzzy.eq(. test) !== test[2]) < console.log("FAIL:", test); allok = false; >else < console.log("OK:", test); >>); console.log(allok ? 'All OK!' : "Some tests FAILED");