Math.fround()

Как проверить является ли переменная числом

Определить является ли значение переменной числом можно используя один из следующих способов:

1. С использованием функций isNaN и isFinite:

Этот способ позволяет определить является ли указанное значение числом или может быть приведено к нему. Данный вариант не считает числом пустую строку, строку из пробелов, значение null , Infinity , -Infinity , true и false .

2. С использованием оператора typeof и функций isFinite, isNaN:

Эта функция определяет имеет ли указанное значение тип Number, а также не принадлежит ли оно к одному из специальных значений Infinity, -Infinity и NaN. Эсли это так, то данная функция возвращает значение true.

3. С помощью метода ECMAScript 6 Number.isInteger(value) . Данный метод позволяет определить, является ли указанное значение целым числом.

Как проверить является ли переменная числом

Определить является ли значение переменной числом можно используя один из следующих способов:

1. С использованием функций isNaN и isFinite:

// myVar — переменная
if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) {
//myVar — это число или может быть приведено к нему
};

В виде функции:

// функция
function isNumeric(value) {
return !isNaN(parseFloat(value)) && isFinite(parseFloat(value));
}
// использование
var myVar = «12px»;
console.log(isNumeric(myVar)); //true

Этот способ позволяет определить является ли указанное значение числом или может быть приведено к нему. Данный вариант не считает числом пустую строку, строку из пробелов, значение null , Infinity , -Infinity , true и false .

2. С использованием оператора typeof и функций isFinite, isNaN:

// функция которая проверяет является ли значение числом
function isNumber(value) {
return typeof value === «number» &&
isFinite(value) &&
!isNaN(value);
};
// использование функции isNumber
isNumber(18); //true
// использование функций для проверки текстовых значений
isNumber(parseFloat(«»)); //false
isNumber(parseFloat(«Infinity»)); //false
isNumber(parseFloat(«12px»)); //true

Эта функция определяет имеет ли указанное значение тип Number, а также не принадлежит ли оно к одному из специальных значений Infinity, -Infinity и NaN. Эсли это так, то данная функция возвращает значение true.

3. С помощью метода ECMAScript 6 Number.isInteger(value) . Данный метод позволяет определить, является ли указанное значение целым числом.

Number.isInteger(«20»); //false, т.к. данный метод не выполняет перевод строки в число
Number.isInteger(20); //true, т.к. данное значение является числом

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

В 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″

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

toFixed ()

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

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

toPrecision ()

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

Сравнение чисел

Для сравнения чисел в JavaScript используются следующие операторы: == (равно), != (не равно), > (больше), (меньше), >= (больше или равно), (меньше или равно).

Например, сравним два числа:

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

Например, в JavaScript сумма чисел (0.2 + 0.4) не равна 0.6:

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

Например, число 0.25₁₀ в двоичную систему преобразуется точно.

Например, число 0.2₁₀ можно преобразовать в 2 систему только с определённой точностью:

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

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

Например, сравнить числа до 2 знаков после запятой используя методы toFixed() и toPrecision() :

Основные математические операции

В JavaScript существуют следующие математические операторы: + (сложение), — (вычитание), * (умножение), / (деление), % (остаток от деления), ++ (увелить значение на 1), — (уменьшить значение на 1).

Кроме этого в JavaScript есть комбинированные операторы: x+=y ( x=x+y ), x-=y ( x=x-y ), x*=y ( x=x*y ), x/=y ( x=x/y ), x%=y ( x=x%y ).

Проверка: isFinite и isNaN

Помните эти специальные числовые значения?

• Infinity (и -Infinity) — особенное численное значение, которое ведёт себя в точности как математическая бесконечность ∞.
• NaN представляет ошибку.

Эти числовые значения принадлежат типу number, но они не являются «обычными» числами, поэтому есть функции для их проверки:

• isNaN(value) преобразует значение в число и проверяет является ли оно NaN:

  alert( isNaN(NaN) ); // truealert( isNaN(“str”) ); // true

  Нужна ли нам эта функция? Разве не можем ли мы просто сравнить === NaN? К сожалению, нет. Значение NaN уникально тем, что оно не является равным ни чему другому, даже самому себе:

  alert( NaN === NaN ); // false

• isFinite(value) преобразует аргумент в число и возвращает true, если оно является обычным числом, т.е. не NaN/Infinity/-Infinity:

  alert( isFinite(“15”) ); // truealert( isFinite(“str”) ); // false, потому что специальное значение: NaNalert( isFinite(Infinity) ); // false, потому что специальное значение: Infinity

Иногда isFinite используется для проверки, содержится ли в строке число:

let num = +prompt(“Enter a number”, ”);// вернёт true всегда, кроме ситуаций, когда аргумент – Infinity/-Infinity или не числоalert( isFinite(num) );

Помните, что пустая строка интерпретируется как 0 во всех числовых функциях, включаяisFinite.

Сравнение Object.is

Существует специальный метод Object.is, который сравнивает значения примерно как ===, но более надёжен в двух особых ситуациях:

1. Работает с NaN: Object.is(NaN, NaN) === true, здесь он хорош.
2. Значения 0 и -0 разные: Object.is(0, -0) === false, это редко используется, но технически эти значения разные.

Во всех других случаях Object.is(a, b) идентичен a === b.

Этот способ сравнения часто используется в спецификации JavaScript. Когда внутреннему алгоритму необходимо сравнить 2 значения на предмет точного совпадения, он использует Object.is (Определение SameValue).

Тригонометрия

Math.sin(x) — возвращает числовое значение от -1 до 1, которое представляет синус переданного (в радианах) угла

Math.cos() — возвращает косинус числа

Math.tan() — возвращает тангенс числа

Math.acos() — возвращает арккосинус числа

Math.asin() — возвращает арксинус числа

Math.atan() — возвращает арктангенс числа в радианах

Math.atan2() — возвращает арктангенс от частного своих аргументов

# Рандомное число (случайное число)

Math.random() — Возвращает случайное число в диапазоне от 0 до 1.

Функция для генерации целых случайных чисел:

Функция вовращает случайное целое число между min (включительно) и max (не включая max)

Сравнение чисел

Для сравнения чисел в JavaScript используются следующие операторы: == (равно), != (не равно), > (больше), = (больше или равно),

Например, сравним два числа:

Console.log(2>3); //false
console.log(5>=3); //true

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

Например, в JavaScript сумма чисел (0.2 + 0.4) не равна 0.6:

Console.log((0.2+0.4)==0.6); //false

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

Например, число 0.25 10 в двоичную систему преобразуется точно.

0.125 × 2 = 0.25 | 0
0.25 × 2 = 0.5 | 0
0.5 × 2 = 1 | 1
0.125 10 = 0.001 2

Например, число 0.2 10 можно преобразовать в 2 систему только с определённой точностью:

0.2 × 2 = 0.4 | 0
0.4 × 2 = 0.8 | 0
0.8 × 2 = 1.6 | 1
0.6 × 2 = 1.2 | 1
0.2 × 2 = 0.4 | 0
0.4 × 2 = 0.8 | 0
0.8 × 2 = 1.6 | 1
0.6 × 2 = 1.2 | 1
0.2 × 2 = 0.4 | 0
0.4 × 2 = 0.8 | 0
0.8 × 2 = 1.6 | 1
0.6 × 2 = 1.2 | 1
…
0.2 10 = 0.001100110011… 2

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

0.6000000000000001==0.6

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

Например, сравнить числа до 2 знаков после запятой используя методы toFixed() и toPrecision() :

//метод toFixed()
console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true
//метод toPrecision()
console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //true

Основные математические операции

В JavaScript существуют следующие математические операторы: + (сложение), — (вычитание), * (умножение), / (деление), % (остаток от деления), ++ (увелить значение на 1), — (уменьшить значение на 1).

6+3 //9
6-3 //3
6*3 //18
6/3 //2
6%3 //0, т.е. 6:3=2 => 6-3*2 => ост(0)
5%2 //1, т.е. 5:2=2(.5) => 5-2*2 => ост(1)
7.3%2 //1.3, т.е. 7.3:2=3(.65) => 7.3-2*3 => ост(1.3)
//знак результата операции % равен знаку первого значения
-9%2.5 //-1.5, т.е. 9:2.5=3(.6) => 9-2.5*3 => ост(1.5)
-9%-2.5 //-1.5, т.е. 9:2.5=3(.6) => 9-2.5*3 => ост(1.5)
-2%5 //-2, т.е. 2:5=0(.4) => 2-5*0 => ост(2)
x = 3;
console.log(x++); //выводит 3, у уже потом устанавливает 4
console.log(x); //4
x = 3;
console.log(++x); //устанавливает 4 и выводит
x = 5;
console.log(x—); //выводит 5, у уже потом устанавливает 4
console.log(x); //4
x = 5;
console.log(—x); //устанавливает 4 и выводит
Кроме этого в JavaScript есть комбинированные операторы: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/=y (x=x/y), x%=y (x=x%y).
x = 3;
y = 6;
x+=y;
console.log(x); //9
x = 3;
y = 6;
x-=y;
console.log(x); //-3
x = 3;
y = 6;
x*=y;
console.log(x); //18
x = 3;
y = 6;
x/=y;
console.log(x); //0.5
x = 3;
y = 6;
x%=y;
console.log(x); //3

Функции из библиотеки Math

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

math.ceil

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

Любая дробь находится между двумя целыми числами. Например, 2.3 лежит между 2 и 3. Функция ceil() определяет большую сторону и возводит к нему результат преобразования. Например:

Алгоритм определяет большую границу интервала с учетом знака:

math.floor

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

При округлении учитывается знак перед данными.

math.trunc

Функция характеризуется отбрасыванием дробной части. После преобразования получается целое значение без учета дроби. Такой алгоритм не является округлением в арифметическом смысле. В Пайтон просто игнорируется дробь независимо от ее значения:

Избавиться от дроби можно без подключения модуля. Для этого есть стандартная функция Она преобразовывает дробные числа в целые путем игнорирования дроби.

Description

If the fractional portion of the argument is greater than 0.5, the argument is rounded to the integer with the next higher absolute value. If it is less than 0.5, the argument is rounded to the integer with the lower absolute value. If the fractional portion is exactly 0.5, the argument is rounded to the next integer in the direction of +∞. Note that this differs from many languages» round() functions, which often round this case to the next integer away from zero

, instead giving a different result in the case of negative numbers with a fractional part of exactly 0.5.

Because round() is a static method of Math , you always use it as Math.round() , rather than as a method of a Math object you created (Math has no constructor).

Пример

//Функция принимает 1 параметр – числоMath.floor(5.1); // 5Math.floor(5.9); // 5

нет оценок

13669 просмотровнет комментариевАртём Фёдоров15 декабря 2011

Категории

ПрограммированиеJavaScriptЧисла в JavaScriptЧисла

• Округление в большую сторону (JavaScript)
• Максимальное число (JavaScript)
• Деление без остатка (JavaScript)
• Округление до знака — JavaScript
• Случайный элемент массива (JavaScript)
• Модальное окно (JavaScript)
• str_repeat (JavaScript)
• str_pad (JavaScript)
• Ассоциативный массив в JavaScript
• JavaScript md5
• Строку в массив (JavaScript)
• JavaScript setcookie getcookie

Округление

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

В 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.floor(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23

Метод toFixed(n) округляет число до n знаков после запятой и возвращает строковое представление результата.

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 знаков после запятой

Мы можем преобразовать полученное значение в число, используя унарный оператор + или Number(), пример с унарным оператором: +num.toFixed(5).

Выбор способа округления

Существует несколько способов округления в зависимости от способа применения результата: округление к меньшему/ большему, округление к меньшему/ большему по модулю, округление к ближайшему целому, округление к ближайшему чётному и т. д… Округление к ближайшему целому, в свою очередь, можно делать по-разному в зависимости от того, какой результат должен получиться, если дробная часть равна 0,5. Я буду рассматривать округление к ближайшему целому, причём 0,5 будет округляться в большую (по модулю) сторону.

Требования к корректной реализации Round() заключаются в следующем:

• правильно округляет до ближайшего целого все конечные числа;
• поддерживает специальные значения (NaN, Inf, -0), возвращая их без изменений.

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

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

Обратите внимание, что, поскольку мы используем float, мы не можем использовать число 0,49999999999999999 в качестве ближайшего к 0,5, так как из-за ограниченной точности float это число в точности равно 0,5. Вместо этого я использую 0,49999999999999994

Реализации, предложенные в закрытом тикете, явно не были проверены на подобных данных, часто не работали даже те из них, которые были предложены известными людьми. Это лишний раз доказывает, насколько сложно написать Round().

int(f + 0.5)

Первая реализация, предложенная rsc, выглядела следующим образом:

Она некорректно работает с особыми значениями, отрицательными числами, числами больше math.MaxInt64 и числами, близкими к 0,5:

Floor() or Ceil()

Второй предложенный вариант учитывал отрицательные числа:

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

Первые два теста не проходят, потому что результат разности n — 0,5 равен в точности -1,0, тогда как мы ожидаем получить что-то точно большее, чем -1,0. Если посмотреть на , можно понять, как решить эту проблему.

Самое интересное, что эта ошибка не является такой уж редкой. До версии 6 точно такая же присутствовала в Java. Хорошо, что с тех пор реализация улучшилась.

int и Copysign

В третьем предложении от minux была предпринята другая попытка решить проблему отрицательных чисел:

И этот вариант всё равно ломает тесты:

Как видно, часть тестов стала проходить, однако другие начали падать. Была предпринята попытка улучшить этот алгоритм:

Однако и она провалилась:

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

Мы рассмотрели уже четыре варианта, и в каждом из них нашлись изъяны. Настало время посмотреть, как Round() реализуют авторы различных пакетов.

Kubernetes

Kubernetes 1.7 содержит реализацию:

Она ломает следующие тесты:

Судя по тому, что функция возвращает int32, она не предназначена для работы с большими числами. Однако она некорректно работает и с числами, которые близки к 0,5.

Примеры

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

Следующий пример показывает использование метода Math.ceil().

Math.ceil(.95); // 1Math.ceil(4); // 4Math.ceil(7.004); // 8Math.ceil(-0.95); // -0Math.ceil(-4); // -4Math.ceil(-7.004); // -7

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

(function() { function decimalAdjust(type, value, exp) { if (typeof exp === ‘undefined’ || +exp === ) { return Mathtype(value); } value = +value; exp = +exp; if (isNaN(value) || !(typeof exp === ‘number’ && exp % 1 === )) { return NaN; } value = value.toString().split(‘e’); value = Mathtype(+(value + ‘e’ + (value1 ? (+value1 – exp) –exp))); value = value.toString().split(‘e’); return +(value + ‘e’ + (value1 ? (+value1 + 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); Math.round10(55.549, –1); Math.round10(55, 1); Math.round10(54.9, 1); Math.round10(–55.55, –1); Math.round10(–55.551, –1); Math.round10(–55, 1); Math.round10(–55.1, 1); Math.floor10(55.59, –1); Math.floor10(59, 1); Math.floor10(–55.51, –1); Math.floor10(–51, 1); Math.ceil10(55.51, –1); Math.ceil10(51, 1); Math.ceil10(–55.59, –1); Math.ceil10(–59, 1);

8 ответов:

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

или как один лайнер:

тестирование с разными значениями:

Если вам нужно округлить до определенного количества цифр использовать следующие функции

по словам спецификация ECMAScript, числа в JavaScript представлены только 64-разрядным форматом двойной точности IEEE 754. Следовательно, в JavaScript на самом деле нет целочисленного типа.

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

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

есть еще toFixed(), который возвращает строку, представляющую число с фиксированной точкой.

Ps.: Есть нет 2-й аргумент в математика.круглый () метод. Элемент toFixed() и не то есть конкретный, его внутри спецификация ECMAScript также

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

вы также можете использовать toFixed(x) или toPrecision(x) здесь x — количество цифр.

оба эти метода поддерживаются во всех основных браузерах

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

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

очень хорошее приближение для округления:

только в некоторых случаях, когда длина десятичной части числа очень длинная, это будет неверно.

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

Внутри 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 воспринимают их одинаковыми.