Как обозначается целое число в js. Методы округления чисел в JavaScript

Это позволяет исправить ответ @ MarkElliot, чтобы он работал и для отрицательных чисел:

Var div = Math.trunc(y/x); var rem = y % x;

Обратите внимание, что методы Math имеют преимущество перед побитовыми операторами, что они работают с числами более 2 31 .

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

FLOOR определяется как «наибольшее целое число, меньшее, чем параметр», таким образом:

• положительные числа: FLOOR (X) = целая часть X;
• отрицательные числа: FLOOR (X) = целая часть X минус 1 (потому что она должна быть SMALLER, чем параметр, т. е. более отрицательный!)

REMAINDER определяется как «оставшееся» деления (евклидова арифметика). Когда дивиденд не является целым числом, фактор обычно также не является целым числом, т. Е. Нет остатка, но если фактор вынужден быть целым числом (и это то, что происходит, когда кто-то пытается получить остаток или модуль число с плавающей запятой), очевидно, будет нецелое «оставленное».

JavaScript вычисляет все так, как ожидалось, поэтому программист должен быть осторожным, чтобы задавать правильные вопросы (и люди должны быть осторожны, чтобы ответить на то, что задано!) Первый вопрос Ярина был НЕ «что такое целочисленное деление X на Y», вместо этого: «Целое число раз, когда данное целое число ИДЕТ В другое». Для положительных чисел ответ один и тот же для обоих, но не для отрицательных чисел, потому что целочисленное деление (дивиденд на делитель) будет -1 меньше, чем число (делитель) «переходит в другое» (дивиденд). Другими словами, FLOOR вернет правильный ответ для целочисленного деления отрицательного числа, но Ярин не спросил об этом!

gammax правильно ответил, этот код работает по заданию Ярина. С другой стороны, Самуил ошибается, он не делал математики, я думаю, или он бы видел, что это действительно работает (также он не сказал, что было делителем его примера, но я надеюсь, что это было 3):

Остаток = X% Y = -100% 3 = -1

GoesInto = (X - Remainder) / Y = (-100 - -1) / 3 = -99 / 3 = -33

Кстати, я тестировал код на Firefox 27.0.1, он работал, как ожидалось, с положительными и отрицательными числами, а также с нецелыми значениями, как для дивидендов, так и для делителей. Пример:

100.34 / 3.57: GoesInto = -28, Remainder = -0.3800000000000079

Да, я заметил, что там есть проблема с высокой точностью, но я не успел ее проверить (я не знаю, есть ли проблема с Firefox, Windows 7 или с FPU моего процессора). Однако для вопроса Ярина, который включает только целые числа, код гаммакса работает отлично.

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

ParseInt(a/b)

Чтобы получить остаток, используйте оператор mod:

parseInt имеют некоторые подводные камни со строками, чтобы избежать использования параметра radix с базой 10

ParseInt("09", 10)

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

ParseInt(100000000000000000000000000000000, 10) // 1e+32

Этот вызов даст результат 1.

Вычисление количества страниц может быть выполнено за один шаг: Math.ceil (x / y)

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

Export function divideBy2(num) { return ; } export function divideBy4(num) { return ; } export function divideBy8(num) { return ; }

(Первое - это частное, второе - остальное)

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

Function intdiv(dividend, divisor) { divisor = divisor - divisor % 1; if (divisor == 0) throw new Error("division by zero"); dividend = dividend - dividend % 1; var rem = dividend % divisor; return { remainder: rem, quotient: (dividend - rem) / divisor }; }

Я не эксперт в побитовых операторах, но вот еще один способ получить целое число:

Var num = ~~(a / b);

Это будет нормально работать и для отрицательных чисел, в то время как Math.floor() будет вращаться в неправильном направлении.

Это тоже кажется правильным:

Var num = (a / b) >> 0;

Math.floor(operation) возвращает округленное значение операции.

Пример 1- го вопроса:

Var x = 5; var y = 10.4; var z = Math.floor(x + y); console.log(z);

Приставка:

Пример 2- го вопроса:

Var x = 14; var y = 5; var z = Math.floor(x%y); console.log(x);

Приставка:

Для некоторого числа y и некоторого дивизора x вычислить фактор (quotient) и остаток (remainder) как:

Var quotient = Math.floor(y/x); var remainder = y % x;

В этой части наших занятий мы познакомимся с объектом Number как с контейнером числового типа данных. Его собственно объектная сущность сегодня будет затронута очень поверхностно.

Так же, как объект String содержит строки текста, объект Number содержит числа. Так же, как и строки, числа, которые мы создаём, атоматически становятся экземплярами объекта.

Тип данных Number

Числа в JavaScript бывают двух видов: целые и с плавающей точкой (разделений на множество типов, как в других языках — integer, long, short, double — здесь нет). Числа с плавающей точкой имеют целую и дробную части, разделённые точкой (независимо от национальных настроек).

Эти два вида чисел не являются самостоятельными типами и не нуждаются в специальной конверсии между собой. Если, например, 32.5 мы умножим на 0.4 , то сразу получим целое число 13 , а не дробь 13.0 , которую нужно конвертировать в целочисленное значение (как сплошь и рядом в других языках).

Создание объекта Number

Как и строку, число обычно создают как экземпляр объекта Number , простым назначением (в отличие от строки, кавычек не требуется).

var myNum = 21 ;

Но можно создать и новый объект с помощью конструктора:

var myNum = new Number ; myNum = 21 ;

В подавляющем большинстве случаев это излишне и даже вредно. Корректные примеры подобной работы с объектами мы рассмотрим в 4-й части.

Представление чисел

Экспоненциальная форма

Числа можно представлять как в обычной, так и в экспоненциальной форме, например:

2e6 // без пробелов!

Это означает: 2 × 10 6

Если мы выведем такое число через метод документа write() , то получим развёрнутое число в обычном представлении.

Document.write (14e12 );

Результат:

Основные системы счисления

Числа можно также представлять как в десятичной, так в шестнадцатеричной и восьмеричной системах.

Целые числа в десятичной форме не должны начинаться с нуля , потому что нуль является префиксом для недесятичных систем. Просто 0 — префикс для восьмеричных значений, а 0x — для шестнадцатеричных.

Например, 075 — это восьмеричное представление десятичного числа 61 , а 0x75 — шестнадцатеричное представление десятичного числа 117 .

Для восьмеричных значений используются цифры от 0 до 7 , для шестнадцатеричных — цифро-буквенный ряд 0123456789ABCDEF . Буквы можно использовать в любом регистре .

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

Представление чисел в других системах

Говоря об объекте String , мы касались метода toString() , который конвертирует любой объект в строку. При конвертации чисел в строки желательно указать как аргумент систему счисления.

Обратите внимание

Исходное число требуется заключить в скобки

(число).toString (система)

система — может принимать любые значения от 2 до 36.

(157 ).toString (2 ); // двоичное представдение 157, равно (53 ).toString (27 ); // экзотическое 27-ричное представдение 53, равно

Но эти полученные выражения являются строками. Чтобы сделать их реальными числами в указанных системах счисления, нужно результат метода toString(система) конвертировать обратно в число. Делается это уже не методом, а функцией ядра Number(объект) . О функциях ядра мы поговорим в одном из ближайших уроков, а пока обратите внимание на синтаксис, он похож на вызов функции:

var a = 1546 ; var b = a.toString (2 ); var c = Number (b);

Или сразу, «два в одном»:

var a = 1546 ; var b = Number (a.toString (2 ));

Примечание

Если исходное число назначено на переменную, то её не надо брать в скобки при вызове метода toString() .

Свойства объекта Number

Общие объектные свойства constructor и prototype мы затронем в уроке об объекте Object , а сейчас обратимся к специфическим свойствам объекта Number .

Эти свойства — только для чтения , то есть мы не можем их изменять.

MAX_VALUE

Максимальное число, доступное для обработки в JavaScript.

Посмотрим, что же это за число такое:

var e = Number .MAX_VALUE document.write (e)

Результат:

1.7976931348623157e+308

Плюс в данном случае — не знак сложения, а положительная степень, то есть 1.7976931348623157 × 10 308

Примечание

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

MIN_VALUE

А это — соответственно — минимальное значение. Исследуем его.

var f = Number .MIN_VALUE document.write (f)

Результат:

То есть 5 × 10 -324

Нечисловое значение, с которым мы уже встречались.

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

NEGATIVE_INFINITY, POSITIVE_INFINITY

Когда-то считали примерно так: «один оленя, два оленя, много оленя».

JavaScript считает чуть более «продвинуто»: «один оленя, два оленя, три оленя, ... , 1.7976931348623157 × 10 308 оленя, много оленя».

Это запредельное «много» выражается свойством POSITIVE_INFINITY .

При обратном процессе — делении единицы («одного оленя») на мелкие-мелкие кусочки — самым мелким считанным кусочком окажется 5 × 10 -324 часть. Всё, что меньше, — это уже NEGATIVE_INFINITY .

Методы объекта Number

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

toExponential()

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

Синтаксис:

число.toExponential (количествоЗнаков )

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

Пример:

var myFullNumber = 4659872156831598853654127 ; document.write (myFullNumber.toExponential(4))

Результат:

toFixed()

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

Синтаксис:

число.toFixed (количествоЗнаков )

Примеры:

var myDecimal1 = 46.59872156831598853654127 ; var myDecimal2 = 46 ; document.write (myDecimal1.toFixed(1)) document.write ("
") document.write (myDecimal2.toFixed(3))

Результаты:

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

function anyRootPlus(x, y) { var srcnum = Math .exp (Math .log (x) / y); var result = (srcnum).toFixed (3); return result; }

А теперь вставим её в форму и протестируем:

Правда, теперь и целые числа будут с тремя нулями после точки. Но, зная поведение чисел и строк, умея работать с условными операторами и конверсией типов, не так уж сложно сделать необходимый числовой «дизайн».

toLocaleString()

Преобразует числовой объект в строковое значение с учётом национальных настроек для десятичных разделителей и разделителей между тысячами. За основу берётся национальная валюта, поэтому в русском варианте все, даже целые, числа представлены с двумя знаками после запятой (копейками):

var myDrob = 25.327 ; var myMnogo = 25635120 ; var myRoubl = 35 ; /* сделаем покрупнее, чтобы лучше разглядеть запятые */ document.write ("

" + myDrob.toLocaleString () + "

" ); document.write ("

" + myMnogo.toLocaleString () + "

" ); document.write ("

" + myRoubl.toLocaleString () + "

" );

Результаты:

toPrecision()

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

Синтаксис:

число.toPrecision (количЦифр )

Аргумент:

количЦифр — количество цифр в отображаемой строке. Если заданное количество больше количества в исходном числе, отображаются десятичные нули.

Document.write ((354 ).toPrecision (8 ))

Результат:

Методы toPrecision() и toLocaleString() совместно не работают , для «русского дизайна» чисел любой точности потребуется написать собственную функцию. Написанную функцию можно сделать дополнительным методом объекта Number , нечто подобное мы уже делали с объектом Date() . Подробнее — в уроке об объекте Object .

toString()

Ну, этот метод мы уже подробно разобрали в начале урока.

Создаём собственный метод

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

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

Объявим метод:

Number.prototype.toRussianString = toRussianString

Прежде чем приступим к построению функции, сформулируем задачи.

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

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

Начнём функцию с объявления нужных переменных.

function toRussianString(prec) { /* переменные для преобразования строк */ var a = "" , b = "" , c, d, e;

Забегая вперёд, скажу, что десятичная часть в результате наших строковых пертурбаций утрачивает свою «дробную» сущность, и работать с ней предстоит как с ещё одним целым числом. Для работы с ней воспользуемся методом toPrecision() , и аргумент нашей функции (а заодно и нашего метода) задаёт значение именно для метода toPrecision() . Минимальный параметр этого метода — единица. А для нашей функции может понадобиться и ноль (при округлении до целого числа). И при этом правильное округление должно сработать ещё до того, как мы начнём «расчленять» объект. Поэтому сразу же при объявлении переменных обойдём этот подводный камень:

/* переменная, конвертирующая в строку заданный экземпляр объекта */ if (prec == 0 ) var str = this .toFixed (0 ).toString toString (10 );

Продолжаем объявление переменных.

/* переменная для возвращаемого значения */ var nr1; /* переменные для частей «расчленёнки» */ var intpart, fractpaft, precpart, divider, dot = str.lastIndexOf ("." ); /* счётчик */ var i;

Переменная dot находит позицию точки в строке указанного числа. По этой позиции отсекаем целую часть (intpart ). Если число целое и точки нет, её позиция будет меньше нуля. В этом случае и разделитель (divider ), и дробная часть (fractpart ) должны быть пустыми строками. В противном случае на разделитель назначается запятая, а дробная часть отсекается для дальнейшей работы:

if (dot < 0 ) { intpart = str; fractpart = "" ; divider = "" ;} else { intpart = str.substring (0 , dot); fractpart = str.substring (dot + 1 , str.length ); divider = "," ;}

Работаем с целой частью. Пробелы нужны только в том случае, если в ней больше 3 символов:

if (intpart.length > 3 ) {

Теперь разложим следующий «пасьянс» (всё это происходит внутри условного оператора):

Пройдём циклом по тройкам в обратном порядке.

Сначала соберём их в переменную a безо всяких добавлений, просто для того, чтобы вычислить длину образовавшейся подстроки. Ведь если общее количество цифр не делилось на 3, то слева остался хвостик из 1 или 2 цифр, и теперь мы можем выразить и его в виде подстроки, отняв от длины всей строки длину подстроки с «тройками» (переменная c ). И поставим перед ним неразрывный пробел — (который потом будем убирать). Зачем? Поскольку группы из трёх цифр считывались в обратном порядке, этот начальный хвостик нужно поместить в конец ряда. То есть, если у нас было число, допустим, 36748521, нам нужно выстроить 521 748 36, ставя перед каждой группой неразрывный пробел, чтобы был разделитель для массива (ведь нам же надо перевернуть их обратно, а это можно сделать с помощью метода массива reverse() ).

В последней инструкции цикла мы расставим в тройках и запишем результат в переменную b .

for (i=intpart.length -3 ; i>=0 ; i-=3 ) /* собираем тройки */ { a = a + intpart.substr (i, 3 ); /* находим левый "хвостик" */ c = " " + intpart.substr (0 , intpart.length -a.length ); /* расставляем в тройках разделители */ b = b + " " + intpart.substr (i, 3 );}

При сложении строк b + c мы получаем строку, которую нужно преобразовать в массив, а затем этот массив перевернуть и снова конвертировать в строку (это всё записывается в переменную d ).

D = (b+c).split (" " ).reverse ().toString ().replace (/,/g, " " );

Массив преобразуется в строку вместе с запятыми-разделителями, они нам не нужны. Поэтому в этой же инструкции удаляем их с помощью регулярного выражения /,/g , где /,/ — создание регулярного выражения для запятой, а g — «флажок», который показывает, что нужно заменить все образцы выражения (попросту говоря — все запятые), которые встретятся в строке. Заменяем их на всё те же неразрывные пробелы.

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

А теперь нужно кое-что ещё почистить (внутри того же условного оператора if (intpart.length > 3) ).

Дело в том, что либо в начале, либо в конце нашей строки окажется лишний неразрывный пробел, состоящий из 6 символов: «&», «n», «b», «s», «p» и «;». Поэтому очистим мусор и запишем результат в переменную e :

if (d.substring (0 , 1 ) == "&" ) e = d.substring (6 , d.length -6 ); else e = d.substring (0 , d.length -6 );

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

} else e = intpart;

Итак, переменная e хранит целую часть числа, а мы займёмся десятичной.

Внимание! Когда мы работаем с дробной частью (с которой теперь нужно обращаться как с целой), мы должны помнить, что при prec == 0 функция «заартачится», поэтому сразу «забьём заглушку»:

if (prec != 0 ) {

Теперь можно работать спокойно. Но есть ещё несколько «камешков», которые мы сейчас обойдём.

Во-первых, если дробная часть у нас, предположим, 41 , а мы задаём округление до 3 знаков, то метод toPrecision , принимая нашу дробную часть за целое число, выведет 41.0 , то есть надо убирать точку.

Во-вторых, если дробная часть исходного числа окажется больше 3 знаков, то метод toPrecision начнёт выдавать результат в экспоненциальной форме. С этим тоже придётся побороться.

Поэтому мы будем «чистить» результат через три переменных: precpart , precpart1 и precpart2 .

Precpart = (Number (fractpart).toPrecision (prec)).toString (10 )

Теперь «чистим»:

/* если дробная часть есть */ if (fractpart != "") { /* ищем и устраняем точку */ precpart1 = precpart.replace (".", "") /* проаеряем, нет ли там экспоненты, */ var plus = precpart1.lastIndexOf("e"); /* и если она есть, */ if (plus > 0 ) /* выдёргиваем с корнем, */ precpart2 = precpart1.substring (0 , plus); /* в противном случае */ else /* ничего не меняем */ precpart2 = precpart1 } /* если дробной части нет, */ else /* то выводим нули и опять же избавляемся от точки */ precpart2 = "," + precpart.replace ("." , "" )

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

} else { /* то есть если всё-таки prec равна нулю, просто выводим пустые строки */ precpart2 = "" ; divider = "" ; }

И финальный аккорд:

Nr1 = e + divider + precpart2; return nr1; }

Вся функция целиком:

function toRussianString(prec) { var a = "" , b = "" , c, d, e; if (prec == 0 ) var str = this .toFixed (0 ).toString (10 ); else var str = this .toString (10 ); var nr1; var intpart, fractpaft, precpart, divider, dot = str.lastIndexOf ("." ); var i; if (dot < 0 ) { intpart = str; fractpart = "" ; divider = "" ;} else { intpart = str.substring (0 , dot); fractpart = str.substring (dot + 1 , str.length ); divider = "," ;} if (intpart.length > 3 ) { for (i=intpart.length -3 ; i>=0 ; i-=3 ) { a = a + intpart.substr (i, 3 ); c = " " + intpart.substr (0 , intpart.length -a.length ); b = b + " " + intpart.substr (i, 3 );} d = (b+c).split (" " ).reverse ().toString ().replace (/,/g, " " ); if (d.substring (0 , 1 ) == "&" ) e = d.substring (6 , d.length -6 ); else e = d.substring (0 , d.length -6 ); } else e = intpart; if (prec != 0 ) { precpart = (Number (fractpart).toPrecision (prec)).toString (10 ) if (fractpart != "") { precpart1 = precpart.replace (".", "") var plus = precpart1.lastIndexOf("e"); if (plus > 0 ) precpart2 = precpart1.substring (0 , plus); else precpart2 = precpart1 } else precpart2 = "," + precpart.replace ("." , "" ) } else { precpart2 = "" ; divider = "" ; } nr1 = e + divider + precpart2; return nr1; }

Теперь эту функцию можно вызывать как метод.

Var myNumber = 2569843359.6583521 document.write (myNumber.toRussianString (3 ))

Результат:

Можете поместить конструктор метода и функцию в библиотеку — то есть в файл.js, который можно вызывать из кода web-страниц. По мере написания методов к разным объектам можно рассортировать методы по библиотечным файлам для этих объектов и пользоваться дополнительными методами.

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

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

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

0.1 * 0.2; > 0.020000000000000004

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

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

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

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

var randNum = 6.25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" var randNum = 87.335; randNum.toFixed(2); > "87.33" var randNum = 87.337; randNum.toPrecision(3); > "87.3"

Примечание

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

console.log(randNum + rounded); > "6.256"

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

var randNum = 6.25; var rounded = parseFloat(randNum.toFixed(1)); console.log(rounded); > 6.3

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

var wholeNum = 1 var dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > "1.00"

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

var num = 123.435 num.toPrecision(2); > "1.2e+2"

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

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

var numTest = 1.005; numTest.toFixed(2); > 1;

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

function round(value, decimals) { return Number(Math.round(value+"e"+decimals)+"e-"+decimals); }

Применение:

round(1.005,2); > 1.01

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

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

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

0.1 + 0.2 === 0.3 > false

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

function epsEqu(x, y) { return Math.abs(x - y) < Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

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

epsEqu(0.1 + 0.2, 0.3) > true

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

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

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

function truncated(num) { return Math.trunc(num * 100) / 100; } truncated(3.1416) > 3.14

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

function truncated(num, decimalPlaces) { var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; }

Использование:

var randInt = 35.874993; truncated(randInt,3); > 35.874

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

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

Math.round(4.3) > 4 Math.round(4.5) > 5

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

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

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

Math.floor(42.23); > 42 Math.floor(36.93); > 36

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

Math.floor(-2.5); > -3

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

Math.trunc(-41.43); > -41

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

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

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

Math.ceil(42.23); > 43 Math.ceil(36.93); > 37 Math.ceil(-36.93); -36

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

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

function roundTo5(num) { return Math.round(num/5)*5; }

Использование:

roundTo5(11); > 10

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

function roundToMultiple(num, multiple) { return Math.round(num/multiple)*multiple; }

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

var initialNumber = 11; var multiple = 10; roundToMultiple(initialNumber, multiple); > 10;

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

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

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

Использование:

var lowBound = 1; var highBound = 100; var numInput = 123; var clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(clamped); > 100;

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

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

Зачем необходимо округление?

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

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Для практических целей эта неточность не имеет никакого значения, в нашем случае мы говорим об ошибке в квинтиллионных долях, однако, кого-то это может разочаровать. Мы можем получить несколько странный результат и при работе с числами, которые представляют собой значения валют, процентов или размеров файла. Для того, чтобы исправить эти неточности, нам как раз и необходимо уметь округлять результаты, при этом достаточно установить десятичную точность.

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

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

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

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

let randNum = 6.25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" randNum = 87.335; randNum.toFixed(2); > "87.33" randNum = 87.337; randNum.toPrecision(3); > "87.3"
Оба метода toFixed() и toPrecision() возвращают строковое представление результата, а не число. Это означает, что при суммировании округленного значения с randNum будет произведена конкатенация строк, а не сумма чисел:

Let randNum = 6.25; let rounded = randNum.toFixed(); // "6" console.log(randNum + rounded); > "6.256"
Если вы хотите, чтобы результат имел числовой тип данных, то вам необходимо будет применить parseFloat:

Let randNum = 6.25; let rounded = parseFloat(randNum.toFixed(1)); console.log(rounded); > 6.3
Обратите внимание, что значения 5 округлены, за исключением редких случаев.

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

Let wholeNum = 1 let dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > "1.00"
Стоить обратите внимание, что toPrecision будет давать результат в экспоненциальной записи, если число целых чисел больше, чем сам сама точность:

Let num = 123.435 num.toPrecision(2); > "1.2e+2"

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

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

Let numTest = 1.005; numTest.toFixed(2); > "1.00"
Результат расчета выше должен был быть 1.01, а не 1. Если вы хотите избежать подобную ошибку, мы можем использовать решение, предложенное Jack L Moore , которое использует экспоненциальные числа для расчета:

Function round(value, decimals) { return Number(Math.round(value+"e"+decimals)+"e-"+decimals); }
Теперь:

Round(1.005,2); > 1.01
Если вы хотите более надежное решение, чем решение показанное выше, вы можете перейти на MDN .

Машинное эпсилон округление

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

0.1 + 0.2 === 0.3 > false
Мы используем Math.EPSILON в нашей функции для получения корректного сравнения:

Function epsEqu(x, y) { return Math.abs(x - y) < Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Функция принимает два аргумента: первый - текущий расчет, второй - ожидаемый результат. Она возвращает сравнение двух:

EpsEqu(0.1 + 0.2, 0.3) > true
Все современные браузеры уже поддерживают ES6 математические функции, но если вы хотите получить поддержку в таких браузерах, как IE 11, используйте polyfills .

Отсечение дробной части

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

Function truncated(num) { return Math.trunc(num * 100) / 100; } truncated(3.1416) > 3.14
Если вы хотите приспособить метод под любое количество знаков после запятой, вы можете воспользоваться двойным побитовым отрицанием :

Function truncated(num, decimalPlaces) { let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; }
Теперь:

Let randInt = 35.874993; truncated(randInt,3); > 35.874

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

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

Math.round(4.3) > 4 Math.round(4.5) > 5
Обратите внимание, что «половина значения», 0.5 округляется в большую сторону по правилам математики .

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

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

Math.floor(42.23); > 42 Math.floor(36.93); > 36
Обратите внимание, что округление в меньшую сторону работает для всех чисел, в том числе и для отрицательных. Представьте небоскреб с бесконечным количеством этажей, в том числе с этажами нижнего уровня (представляющий отрицательные числа). Если вы находитесь в лифте на нижним уровнем между 2 и 3 (что представляет собой значение -2.5), Math.floor доставит вас до -3:

Math.floor(-2.5); > -3
Но если вы хотите избежать подобной ситуации, используйте Math.trunc , поддерживаемый во всех современных браузерах (кроме IE / Edge):

Math.trunc(-41.43); > -41
На MDN вы найдете polyfill, который обеспечит поддержку Math.trunc в браузерах и IE / Edge.

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

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

Math.ceil(42.23); > 43 Math.ceil(36.93); > 37 Math.ceil(-36.93); > -36

Округление до большего/меньшего необходимого числа

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

Function roundTo5(num) { return Math.round(num/5)*5; }
Теперь:

RoundTo5(11); > 10
Если вы хотите округлять до кратных своему значению, мы использовать более общую функцию, передавая в нее начальное значение и кратное:

Function roundToMultiple(num, multiple) { return Math.round(num/multiple)*multiple; }
Теперь:

Let initialNumber = 11; let multiple = 10; roundToMultiple(initialNumber, multiple); > 10;

Фиксирование числа в диапазоне

Есть много случаев, когда мы хотим получить значение х, лежащее в пределах диапазона. Например, нам может понадобиться значение от 1 до 100, но при этом мы получили значение 123. Для того, чтобы исправить это, мы можем использовать минимальное (возвращает наименьшее из набора чисел) и максимальное (возвращает наибольшее из любого множества чисел). В нашем примере, диапазон от 1 до 100:

Let lowBound = 1; let highBound = 100; let numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(clamped); > 100;
Опять же, мы можем переиспользовать операцию и обернуть все это в функцию, воспользуемся решением предложенное Daniel X. Moore :

Number.prototype.clamp = function(min, max) { return Math.min(Math.max(this, min), max); };
Теперь:

NumInput.clamp(lowBound, highBound); > 100;

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

Гауссово округление, также известное как банковское округлением, заключается в том, что округление для этого случая происходит к ближайшему чётному. Этот метод округления работает без статистической погрешности. Лучшее решение было предложено Tim Down :

Function gaussRound(num, decimalPlaces) { let d = decimalPlaces || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.floor(n), f = n - i, e = 1e-8, r = (f > 0.5 - e && f < 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }
Теперь:

GaussRound(2.5) > 2 gaussRound(3.5) > 4 gaussRound(2.57,1) > 2.6
Десятичный знак в CSS:

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

#box { width: 63.667731993px; }
Хорошая новость заключается в том, что современные браузеры будут учитывать десятичные значения в блочной модели, в том числе в процентных или пиксельных единицах измерения.

Сортировка

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

Сортировка в алфавитном порядке

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

Let fruit = ["butternut squash", "apricot", "cantaloupe"]; fruit.sort(); > "apricot", "butternut squash", "cantaloupe"]
Тем не менее мы сталкиваемся с проблемой, как только один из элементов находится в верхнем регистре:

Let fruit = ["butternut squash", "apricot", "Cantalope"]; fruit.sort(); > "Cantaloupe", "apricot", "butternut squash"]
Это связано с тем, что, по умолчанию, сортировщик сравнивает первый символ представленный в Unicode . Unicode - это уникальный код для любого символа, независимо от платформы, независимо от программы, независимо от языка. Например, если смотреть по кодовой таблице символ «a» имеет значение U+0061 (в шестнадцатеричной системе 0x61), в то время как символ «C» имеет код U+0043 (0x43), который идет раньше в Unicode-таблице, чем символ «a».

Чтобы отсортировать массив, который может содержать смешанные регистры первых букв, нам необходимо либо преобразовать все элементы временно в нижний регистру, или определить свой порядок сортировки при помощи метода localeCompare() c некоторыми аргументами. Как правило, для такого случая, лучше сразу создать функцию для многократного использования:

Function alphaSort(arr) { arr.sort(function (a, b) { return a.localeCompare(b, "en", {"sensitivity": "base"}); }); } let fruit = ["butternut squash", "apricot", "Cantaloupe"]; alphaSort(fruit) >
Если вы хотите получить массив отсортированный в обратный алфавитном порядке, просто поменяйте позициями а и b в функции:

Function alphaSort(arr) { arr.sort(function (a, b) { return b.localeCompare(a, "en", {"sensitivity": "base"}); }); } let fruit = ["butternut squash", "apricot", "Cantaloupe"]; alphaSort(fruit) > ["Cantaloupe", "butternut squash", "apricot"]
Тут стоит обратить внимание, что localeCompare используется с аргументами, еще надо помнить, что он поддерживается IE11+, для более старых версий IE, мы можем использовать его без аргументов, и в нижнем регистре:

Function caseSort(arr) { arr.sort(function (a, b) { return a.toLowerCase().localeCompare(b.toLowerCase()); }); } let fruit = ["butternut squash", "apricot", "Cantaloupe"]; caseSort(fruit) > ["apricot", "butternut squash", "Cantaloupe"]

Числовая сортировка

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

Let highScores = ; highScores.sort(); >
Дело в том, что метод sort() производит лексикографическую сравнение : а это означает, что числа будут преобразованы в строку и сравнения будут снова проводиться путем сопоставления первого символа этой строки в порядке символов Unicode-таблицы. Поэтому нам снова необходимо определить свой порядок сортировки:

Let highScores = ; highScores.sort(function(a,b) { return a - b; }); >
Опять же, для сортировки чисел в обратном порядке, поменяйте позициями a и b в функции.

Сортировка JSON-подобной структуры

И наконец, если у нас есть JSON-подобная структура данных , представленная как массив игровых рекордов:

Let scores = [ { "name": "Daniel", "score": 21768 }, { "name": "Michael", "score": 33579 }, { "name": "Alison", "score": 38395 } ];
В ES6+, вы можете использовать стрелочные функции:

Scores.sort((a, b) => b.score - a.score));
Для старых браузеров, не имеющих такую поддержку:

Scores.sort(function(a, b) { return a.score - b.score });
Как видите, сортировка в JavaScript это довольно не очевидная вещь, я надеюсь, что эти примеры облегчат как-нибудь жизнь.

Работа со степенными функциями

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

В JavaScript степенная функция представлена как Math.pow(), в новом стандарте ES7 был представлен новый оператор возведения в степень - " * * ".

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

Для того, чтобы возвести число в n-ую степень, используйте функцию Math.pow(), где первый аргумент это число, которое будет возведено в степень, второй аргумент это показатель степени:

Math.pow(3,2) > 9
Такая форма записи означает 3 в квадрате, или 3 × 3, что приводит к результату 9. Можно привести еще пример, конечно:

Math.pow(5,3); > 125
То есть, 5 в кубе, или 5 × 5 × 5, равно 125.

ECMAScript 7 - это следующая версия JavaScript, в принципе, мы можем использовать новый предложенный оператор возведения в степень - * *, такая форма записи может быть более наглядной:

3 ** 2 > 9
На данный момент поддержка этого оператора довольно ограниченная , поэтому его не рекомендуется использовать.

Степенная функция может пригодиться в самых разных ситуациях. Простой пример, вычисление количества секунд в часе: Math.pow (60,2).

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

Math.sqrt() и Math.cbrt() противоположны функции Math.pow(). Как мы помним, квадратный корень из числа a - число, дающее a при возведении в квадрат.

Math.sqrt(9) > 3
В тоже время кубический корень из числа a - число, дающее a при возведении в куб.

Math.cbrt(125) > 5
Math.cbrt() был введен в спецификацию JavaScript совсем недавно, и поэтому поддерживается только в современных браузерах: Chrome 38+, Firefox и Opera 25+ и Safari 7.1+. Вы заметите, что Internet Explorer отсутствует в этом списке, однако на MDN вы найдете полифилл .

Примеры

Конечно, мы можем использовать и не целые значения в одной из этих функций:

Math.pow(1.25, 2); > 1.5625 Math.cbrt(56.57) > 3.8387991760286138
Обратите внимание, что это вполне себе работает и при использовании отрицательных значениях аргументов:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0.01
Тем не менее, для квадратного корня это не будет работать:

Math.sqrt(-9) > NaN
Из математического анализа мы знаем, что под мнимым числом понимают квадратные корни из отрицательных чисел. И это может привести нас к еще одной технике работы с комплексными числами, но это уже другая история.

Вы можете использовать дробные значения в Math.pow(), чтобы найти квадратные и кубические корни чисел. Квадратный корень использует показатель 0.5:

Math.pow(5, 0.5); // = Math.sqrt(5) = 5 ** (1/2) > 2.23606797749979
Однако, из-за капризов с плавающей точкой, вы не можете точно предположить правильный результат:

Math.pow(2.23606797749979,2) > 5.000000000000001
В таких ситуациях, вы вам придется прибегать к отсечению знаков у числа или округление до какого-либо значения.

Некоторые, по непонятным причинам в JavaScript путают функцию Math.pow() с Math.exp() , которая является экспоненциальной функцией для чисел, в целом. Примечание: в английском языке «показатель степени» переводится как «exponent», поэтому это скорее относится к англоговорящим, хотя существуют и альтернативные названия показателя степени , такие как index, power.

Математические константы

Работа с математикой в JavaScript облегчается за счет ряда встроенных констант. Эти константы являются свойствами объекта Math. Стоит обратить внимание, что константы пишутся в верхнем регистре, а не CamelCase нотации.

Math.abs, parseInt, parseFloat

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

Math.abs()

Метод Math.abs() возвращает абсолютное значение числа, что напоминает нам аналогичную математическую функцию модуля числа a .

Let newVal = -57.64; Math.abs(newVal); > 57.64
Math.abs(0) всегда возвращает нуль, но если поставить знак минус перед функцией -Math.abs(NUM) мы всегда будем отрицательное значение.

Math.abs(0); > -0

parseInt()

Мы знаем, что JavaScript понимает, что «15» это строка, а не число и, например, при разборе CSS-свойств средствами JavaScript, или получив какое-либо значение из неподготовленного массива, наши результаты могут получиться непредсказуемыми. Мы могли получить на вход строку представленную как «17px», и для нас это не является редкостью. Вопрос заключается в том, как преобразовать эту строку в фактическое значение и использовать его в дальнейших расчетах.

Синтаксис: parseInt(string, radix);

Функция parseInt преобразует первый переданный ей аргумент в строковый тип, интерпретирует его и возвращает целое число или значение NaN. Результат (если не NaN) является целым числом и представляет собой первый аргумент (string), рассматривающийся как число в указанной системе счисления (radix). Например, основание 10 указывает на преобразование из десятичного числа, 8 - восьмеричного, 16 - шестнадцатеричного и так далее. Если основание больше 10, то для обозначения цифр больше 9 используются буквы. Например, для шестнадцатеричных чисел (основание 16) используются буквы от A до F.

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

Let elem = document.body; let centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087.19px"
Мы можем разделить значения по пробелам:

Let centers = centerPoint.split(" "); > ["454px", "2087.19px"]
Однако, каждый элемент все еще есть строка, мы можем избавиться от этого применив нашу функцию:

Let centerX = parseInt(centers, 10); > 454 let centerY = parseInt(centers, 10); > 2087
Как видите, вторым аргументом мы указываем систему счисления, в которую будет преобразовано число, этот параметр необязательный, но его рекомендуется использовать, в случае, если вы не знаете какая строка поступит на вход.

parseFloat()

Из примера выше, вы наверное заметили, что parseInt отбрасывает дробную часть. В нашем случае, parseFloat умеет работать с числами с плавающей точкой. Опять же, это может быть полезным при разборе CSS и других задачах, особенно при работе с плавающей точкой в ​​процентах.

Синтаксис: parseFloat(string)

Let FP = "33.33333%"; console.log(parseFloat(FP)); > 33.33333
Обратите внимание, что в синтаксисе parseFloat нет второго аргумента.

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

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

Функция isFinite

Функция isFinite позволяет проверить, является ли аргумент конечным числом.

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

IsFinite(73); // true isFinite(-1/0); // false isFinite(Infinity); // false isFinite(NaN); // false isFinite("Текст"); // false

Кроме глобальной функции isFinite в JavaScript имеется ещё метод Number.isFinite . Он в отличие от isFinite не осуществляет принудительное приведения аргумента к числу.

IsFinite("73"); // true Number.isFinite("73"); // false

Функция isNaN

Функция isNaN предназначена для определения того, является ли аргумент числом или может ли быть преобразован к нему. Если это так, то функция isNaN возвращает false. В противном случае она возвращает true.

IsNaN(NaN); //true isNaN("25px"); //true, т.к. 20px - это не число isNaN(25.5); //false isNaN("25.5"); //false isNaN(" "); //false, т.к. пробел или неcколько пробелов преобразуется к 0 isNaN(null); //false, т.к. значение null преобразуется к 0 isNaN(true); //false, т.к. значение true преобразуется к 1 isNaN(false); //false, т.к. значение false преобразуется к 0

Если это действие нужно выполнить без приведения типа, то используйте метод Number.isNaN . Данный метод был введён в язык, начиная с ECMAScript 6.

Как явно преобразовать строку в число?

Явно привести строку в число можно посредством следующих способов:

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

+"7.35"; // 7.35 +"текст"; // NaN

Этот способ пренебрегает пробелами в начале и конце строки, а также \n (переводом строки).

+" 7.35 "; //7.35 +"7.35 \n "; //7.35

Используя данный способ необходимо обратить внимание на то, что пустая строка или строка, состоящая из пробелов и \n , переводится в число 0. Кроме этого она также преобразует тип данных null и логические значения к числу.

Null; //0 +true; //1 +false; //0 +" "; //0

2. Функция parseInt . Данная функция предназначена для преобразования аргумента в целое число . В отличие от использования унарного оператора + , данный метод позволяет преобразовать строку в число, в которой не все символы являются цифровыми . Начинает она преобразовывать строку, начиная с первого символа. И как только она встречает символ, не являющийся цифровым, данная функция останавливает свою работу и возвращает полученное число.

ParseInt("18px"); //18 parseInt("33.3%"); //33

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

ParseInt("18px", 10); //18 parseInt("33.3%", 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181

Кроме функции parseInt в JavaScript имеется метод Number.parseInt . Данный метод ничем не отличается от функции parseInt и был введён в JavaScript со спецификацией ECMASCRIPT 2015 (6).

3. Функция parseFloat . Функция parseFloat аналогична parseInt , за исключением того что позволяет выполнить преобразование аргумента в дробное число.

ParseFloat("33.3%"); //33.3

Кроме этого функция parseFloat в отличие от parseInt не имеет 2 аргумента, и следовательно она всегда пытается рассмотреть строку как число в десятичной системе счисления.

ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0.0314E+2");

Кроме функции parseFloat в JavaScript имеется метод Number.parseFloat . Данный метод ничем не отличается от функции parseFloat и был введён в JavaScript со спецификацией ECMASCRIPT 2015 (6).

Преобразование числа в строку

Превратить число в строку можно с помощью метода toString .

(12.8).toString(); //"12.8"

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

(255).toString(16); //"ff"

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

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

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, т.к. данное значение является числом

Чётные и нечётные числа

Проверить является ли число чётным или нечётным можно посредством следующих функций:

// Функция для проверки числа на чётность function isEven(n) { return n % 2 == 0; } // Функция для проверки числа на нечётность function isOdd(n) { return Math.abs(n % 2) == 1; }

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

Value = 20; if (Number.isInteger(value)) { if (isEven(value)) { console.log("Число " + value.toString() + " - чётное"); } }

Простые числа в Javascript

Рассмотрим пример в котором выведем с помощью Javascript простые числа от 2 до 100.

// Функция, которая проверяет является ли число простым function isPrime(value) { if (isNaN(value) || !isFinite(value) || value%1 || value < 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

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

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

1. Используя специально предназначенные для этого методы Math.floor , Math.ceil и Math.round . Метод Math.floor округляет дробное число до ближайшего целого вниз, т.е. попросту отбрасывает дробную часть. Math.ceil скругляет дробное число до ближайшего целого вверх. Math.round округляет число вверх или вниз в зависимости от значения дробной части. Если дробная часть больше или равно 0.5, то вверх, иначе скруление осуществляется вниз.

Console.log(Math.floor(7.9)); //7 console.log(Math.ceil(7.2)); //8 console.log(Math.round(7.5)); //8

2. С помощью метода toFixed(точность) . Данный метод округляет дробную часть числа до заданной точности. Результат округления возвращает в виде строки.

Console.log(7.987.toFixed(2)); //"7.99"

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

Console.log(7.987.toFixed(5)); //"7.98700"

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

Console.log((1001).toPrecision(2)); //"1.0e+3" console.log((1001).toPrecision(5)); //"1001.0" console.log((12.4).toPrecision(1)); //"1e+1" console.log((12.4).toPrecision(2)); //"12" console.log((12.4).toPrecision(3)); //"12.4" console.log((12.4).toPrecision(5)); //"12.400"

4. Используя логические операторы НЕ или ИЛИ.

//посредством двойного логического отрицания console.log(~~7.9); //7 // посредством использования логического ИЛИ с нулём: console.log(7.9^0); //7

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

Получить целую часть числа можно используя метод 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"); }

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

В 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 используются следующие операторы: == (равно), != (не равно), > (больше), < (меньше), >= (больше или равно), <= (меньше или равно).

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

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