Проверка что число javascript

Способы валидации чисел в JavaScript

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

Валидация целых чисел

Рассмотрим 4 способа валидации переменной « value » на простое число. Все представленные выражения возвращают булевый тип — « true » или « false ».

Недостаток — возвращает положительный результат для значений с нулём в начале, например: 05, 0007, 011. В некоторых случаях это может быть критично.

Для отсеивания отрицательных чисел добавьте дополнительное условие:

Функция «isNaN» работает противоположно предыдущему методу, поэтому вызываем её со знаком отрицания. Недостатки те же.

Один из самых популярных способов — валидация регулярным выражением:

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

А это оригинальный подход с использованием операции побитового исключающего ИЛИ:

Дополнительная проверка на пустоту обязательна, потому что (» ^ 0) == » вернёт «true».

Закончим функцией преобразования переменной в десятичную систему исчисления. Если в качестве параметра будет не число, то функция вернёт «NaN», а сравнение — «false».

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

Для проверки переменной на число с точкой (запятой) в JS наиболее распространены три способа.

Применение функции «parseFloat».

Регулярное выражение, позволяющее указать, сколько допускается знаков после точки. Истинное значение вернется если будет не более 2х.

Разрешаем 4 знака после точки и отрицательные числа:

Применение функции «isNaN» в комплексе с нахождением точки.

Проверка на чётность

Для проверки на чётность в JS используют оператор остатка от деления.

Сравнение вернёт истину, если « value » чётное число и ложь — если нечётное.

Источник

Числа

В современном JavaScript существует два типа чисел:

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

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

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

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

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

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

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

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

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

toString(base)

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

Округление

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

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

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

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

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

Умножить и разделить.

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

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

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

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

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

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

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

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

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

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

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

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

Источник

(Встроенный) способ в JavaScript, чтобы проверить, является ли строка допустимым числом

19 ответов

чтобы проверить, является ли переменная (включая строку) числом, проверьте, не является ли она числом:

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

примеры

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

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

примеры

чтобы преобразовать строку свободно в число

полезно для преобразования «12px» в 12, например:

примеры

терки

пустые строки

пустые строки могут быть немного контр-интуитивными. +num преобразует пустые строки в ноль и isNaN() предполагает то же самое:

но parseInt() не согласен:

и вы можете пойти RegExp-way:

проблема с parseFloat() это то, что он вернет номер если строка содержит любое число, даже если строка не содержит только и ровно номер:

проблема с Number() это то, что он вернет число в случаях, когда переданное значение не является числом вообще!

проблема с прокруткой собственного регулярного выражения заключается в том, что если вы не создадите точное регулярное выражение для сопоставления числа с плавающей запятой, поскольку Javascript распознает его, вы пропустите случаи или распознаете случаи где тебе не следует. И даже если вы можете свернуть свой собственный regex, почему? Есть более простые встроенные способы сделать это.

однако, оказывается, что Number() (и isNaN() ) делает правильную вещь для каждого случая, когда parseFloat() возвращает число, когда оно не должно, и наоборот. Поэтому, чтобы узнать, действительно ли строка является точной и только числом, вызовите обе функции и посмотрите, если они и return true:

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

разрешить только положительное целые числа используют это:

функция isNaN () определяет, является ли значение незаконным числом (не-число).

эта функция возвращает true, если значение равно NaN. В противном случае он возвращает значение false.

эта функция отличается от номера конкретного количество.isNaN() метод.

глобальная функция isNaN () преобразует проверенное значение в число, а затем проверяет его.

количество.isNan () не преобразует значения в число и не возвращает true для любого значения, которое не относится к типу Number.

старый вопрос, но в данных ответах отсутствует несколько пунктов.

научная нотация.

большие плавающие числа могут вести себя странно

соблюдать (через узел.в JS):

бесконечность

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

— это не такая простая задача. Вот простой версия:

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

parseInt (), но имейте в виду, что эта функция немного отличается в том смысле, что она, например, возвращает 100 для parseInt («100px»).

если аргумент (строка) не может быть преобразован в число, он возвращает NaN, поэтому вы можете определить, была ли строка допустимым числом или нет.

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

использует String и Number конструктор для приведения строки в число и обратно и, таким образом, проверяет, является ли движок JavaScript «идеальной минимальной формой» (той, в которую он был преобразован с начальным Number конструктор) соответствует исходной строке.

я протестировал, и решение Майкла лучше всего. Проголосуйте за его ответ выше (найдите на этой странице «Если вы действительно хотите убедиться, что строка», чтобы найти его). В сущности, его ответ таков:—4—>

это работает для каждого тестового случая, который я здесь описаны: https://jsfiddle.net/wggehvp9/5/

многие другие решения терпят неудачу для этих крайних случаев: », null,»», true и []. В теории, вы могли бы использовать их с правильной обработкой ошибок, для пример:

С специальную обработку /\s/, null,»», true, false, [] (и другие?)

Ну, я использую этот, который я сделал.

он работает до сих пор:

Если вы заметили какие-либо проблемы с ним, скажи, пожалуйста.

isNaN (num) // возвращает true, если переменная не содержит допустимого числа

Почему реализация jQuery недостаточно хороша?

следующее решение с наиболее вероятной плохой производительностью, но солидными результатами. Это хитрое приспособление, сделанное из реализации jQuery 1.12.4 и ответа Майкла, с дополнительной проверкой на ведущие / конечные пробелы (потому что версия Майкла возвращает true для чисел с начальные/конечные пробелы):

последняя версия имеет две новые переменные. Можно обойти один из них, сделав:

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

Источник

Проверьте, является ли переменная числом или строкой в ​​JavaScript

Кто-нибудь знает, как я могу проверить, является ли переменная числом или строкой в JavaScript?

29 ответов

Возможно, более надежным методом проверки типа было бы использование метода, найденного в underscore.js (аннотированный источник может быть здесь),

Это возвращает логическое значение true для следующего:

Для определения чисел важен следующий отрывок из JavaScript: «Хорошие части» Дугласа Крокфорда:

typeof variable === ‘number’ | самый быстрый | если вы хотите число, например, 5, а не «5»
typeof parseFloat(variable) === ‘number’ | самый быстрый | если вы хотите число, например, 5 и 5

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

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

Просто и тщательно:

Контрольные примеры:

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

Проверка типа

Вы можете проверить тип переменной с помощью оператора typeof :

Проверка значения

Код ниже возвращает true для чисел и false для всего остального:

Ответ @ BitOfUniverse хорош, и я придумываю новый способ:

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

Если вы ищете реальный тип, тогда подойдет только typeof.

Лучший способ, который я нашел, который также думает о положительных и отрицательных числах, от: O’Reilly Javascript и DHTML Cookbook:

Typeof работает очень хорошо для меня в большинстве случаев. Вы можете попробовать использовать оператор if

Просто к сведению, если вы используете JQuery у вас есть

Это решение решает многие из поднятых здесь проблем!

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

Пример правильности

JQuery использует это:

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

Так что, если вы заботитесь о производительности, я бы использовал это:

Или просто используйте инвертирование isNaN() :

Ну как насчет просто:

Вы можете просто разделить его на 1?

Я предполагаю, что проблема заключалась бы в строковом вводе типа: «123ABG»

Просто так, как я это сделал недавно.

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

Есть ли случаи, когда это не удается?

Это выглядит немного быстрее, чем x===true || x===false или typeof x===»boolean» (и намного быстрее, чем x===Boolean(x) ).

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

Источник

Работа с числами в JavaScript

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

Функция isFinite

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

Функция isNaN

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Кроме этого в 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 ).

Источник