Как сравнить только дробные части чисел 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 , которому принадлежит этот метод.

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 . isNa N ( ) . В качестве аргумента нужно передать проверяемую переменную.

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

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

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

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

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

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

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

Числа

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

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

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

let billion = 1000000000;

Мы также можем использовать символ нижнего подчёркивания _ в качестве разделителя:

let billion = 1_000_000_000

Символ нижнего подчёркивания _ – это «синтаксический сахар», он делает число более читабельным. Движок JavaScript попросту игнорирует _ между цифрами, поэтому в примере выше получается точно такой же миллиард, как и в первом случае.

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

В JavaScript, чтобы укоротить запись числа, мы можем добавить к нему букву «e» и указать необходимое количество нулей:

let billion = 1e9; // 1 миллиард, буквально: 1 и 9 нулей alert( 7.3e9 ); // 7.3 миллиарда (7,300,000,000)

Другими словами, «e» умножает число на 1 с указанным количеством нулей.

1e3 === 1 * 1000 // e3 означает *1000 1.23e6 === 1.23 * 1000000 // e6 означает *1000000

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

let mcs = 0.000001;

В этом случае нам также поможет «e» . Если мы хотим избежать записи длинной последовательности из нулей, мы можем сделать так:

let ms = 1e-6; // шесть нулей слева от 1

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

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

// 1 делится на 1 с 3 нулями 1e-3 === 1 / 1000 (=0.001) // 1.23 делится на 1 с 6 нулями 1.23e-6 === 1.23 / 1000000 (=0.00000123)

Шестнадцатеричные, двоичные и восьмеричные числа

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

alert( 0xff ); // 255 alert( 0xFF ); // 255 (то же самое, регистр не имеет значения)

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

let a = 0b11111111; // двоичная (бинарная) форма записи числа 255 let b = 0o377; // восьмеричная форма записи числа 255 alert( a == b ); // true, с двух сторон число 255

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

toString(base)

Метод num.toString(base) возвращает строковое представление числа num в системе счисления base .

let num = 255; alert( num.toString(16) ); // ff alert( num.toString(2) ); // 11111111

base может варьироваться от 2 до 36 (по умолчанию 10 ).

• base=16 — для шестнадцатеричного представления цвета, кодировки символов и т.д., цифры могут быть 0..9 или A..F .
• base=2 — обычно используется для отладки побитовых операций, цифры 0 или 1 .
• base=36 — максимальное основание, цифры могут быть 0..9 или A..Z . То есть, используется весь латинский алфавит для представления числа. Забавно, но можно использовать 36 -разрядную систему счисления для получения короткого представления большого числового идентификатора. К примеру, для создания короткой ссылки. Для этого просто преобразуем его в 36 -разрядную систему счисления:

alert( 123456..toString(36) ); // 2n9c

Две точки для вызова метода

Внимание! Две точки в 123456..toString(36) это не опечатка. Если нам надо вызвать метод непосредственно на числе, как toString в примере выше, то нам надо поставить две точки .. после числа.

Если мы поставим одну точку: 123456.toString(36) , тогда это будет ошибкой, поскольку синтаксис JavaScript предполагает, что после первой точки начинается десятичная часть. А если поставить две точки, то JavaScript понимает, что десятичная часть отсутствует, и начинается метод.

Также можно записать как (123456).toString(36) .

Округление

Одна из часто используемых операций при работе с числами – это округление.

В JavaScript есть несколько встроенных функций для работы с округлением:

Math.floor Округление в меньшую сторону: 3.1 становится 3 , а -1.1 — -2 . Math.ceil Округление в большую сторону: 3.1 становится 4 , а -1.1 — -1 . Math.round Округление до ближайшего целого: 3.1 становится 3 , 3.6 — 4 , а -1.1 — -1 . Math.trunc (не поддерживается в Internet Explorer) Производит удаление дробной части без округления: 3.1 становится 3 , а -1.1 — -1 .

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

Math.floor	Math.ceil	Math.round	Math.trunc
3.1	3	4	3	3
3.6	3	4	4	3
-1.1	-2	-1	-1	-1
-1.6	-2	-1	-2	-1

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

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

Есть два пути решения:

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

let num = 1.23456; alert( Math.round(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23

let num = 12.34; alert( num.toFixed(1) ); // "12.3"

Округляет значение до ближайшего числа, как в большую, так и в меньшую сторону, аналогично методу Math.round :

let num = 12.36; alert( num.toFixed(1) ); // "12.4"

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

let num = 12.34; alert( num.toFixed(5) ); // "12.34000", добавлены нули, чтобы получить 5 знаков после запятой

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

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

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

alert( 1e500 ); // Infinity

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

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

alert( 0.1 + 0.2 == 0.3 ); // false

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

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

alert( 0.1 + 0.2 ); // 0.30000000000000004

Ой! Здесь гораздо больше последствий, чем просто некорректное сравнение. Представьте, вы делаете интернет-магазин и посетители формируют заказ из 2-х позиций за $0.10 и $0.20 . Итоговый заказ будет $0.30000000000000004 . Это будет сюрпризом для всех.

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

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

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

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

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

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

alert( 0.1.toFixed(20) ); // 0.10000000000000000555