Javascript является ли цифрой

3 ways to check if variable is a number in JavaScript

I was building a form the other day in Vue and I had to write number validation for the field so had to write the logic to check whether the input value is number or not. I wanted to list out the few ways I learnt which might be helpful to others.

NOTE: In JavaScript, special values like NaN , Infinity and -Infinity are numbers too — though, we’ll be ignoring those values.

1) Using isNan()

The isNaN() determines whether a value is NaN or not. We can take advantage of this to determine whether a variable is number type or not.

var numberOfpushUpsToday = 34; if(!isNaN(numberOfpushUpsToday)) console.log('It is a number') > else  console.log('It is not a number') > 

!isNaN(34) // returns true !isNaN('34') // returns true !isNaN('Hello') // returns false !isNaN(true) // returns true !isNaN(false) // returns true !isNaN('undefined') // returns false 

Limitations:

1) It returns true for the Boolean values because the Boolean values are converted to numbers 0 and 1 accordingly so it would be misleading sometimes.
2) We have same issue for the null value as well. It returns true and hence one has to be careful while writing the code.

2) Using typeof()

num = 45 strng = '34' typeof num // returns 'number' typeof strng // returns "string" typeof undefined // returns "undefined" typeof null // returns "object" 

If the variable is type number, it would return the string number . We can use this to determine if the variable is number type.

var numberOfpushUpsToday = 34; if(typeof numberOfpushUpsToday === 'number' ) console.log('It is a number') > else  console.log('It is not a number') > 

The typeof() performs much better than isNaN() . It correctly determines that a string variable, null and Boolean values are not numbers.

3) Using Number.isFinite()

The function isFinite() determines if the passed value is finite. The arguments are first converted to numbers and then checks if the value is finite and hence this is the most best way among all the methods mentioned above.

Number.isFinite(34) // returns true Number.isFinite('Hello') // returns false Number.isFinite(undefined) // returns false Number.isFinite(true) // returns false Number.isFinite(null) // returns false 

var numberOfpushUpsToday = 34; if(Number.isFinite(numberOfpushUpsToday) ) console.log('It is a number') > else  console.log('It is not a number') > 

Conclusion:

Although these methods can get tricky with Boolean values, undefined and null , they are helpful in solving some problems in day to day life. One just have to be careful while writing the code according to their needs. And that sums it up.
Thank you..
Comment below if you have any feedback or thoughts.

Top comments (8)

I’m a self-taught dev focused on websites and Python development. My friends call me the «Data Genie». When I get bored, I find tech to read about, write about and build things with.

Источник

Number.isInteger()

The Number.isInteger() static method determines whether the passed value is an integer.

Try it

Syntax

Parameters

The value to be tested for being an integer.

Return value

The boolean value true if the given value is an integer. Otherwise false .

Description

If the target value is an integer, return true , otherwise return false . If the value is NaN or Infinity , return false . The method will also return true for floating point numbers that can be represented as integer. It will always return false if the value is not a number.

Note that some number literals, while looking like non-integers, actually represent integers — due to the precision limit of ECMAScript floating-point number encoding (IEEE-754). For example, 5.0000000000000001 only differs from 5 by 1e-16 , which is too small to be represented. (For reference, Number.EPSILON stores the distance between 1 and the next representable floating-point number greater than 1, and that is about 2.22e-16 .) Therefore, 5.0000000000000001 will be represented with the same encoding as 5 , thus making Number.isInteger(5.0000000000000001) return true .

In a similar sense, numbers around the magnitude of Number.MAX_SAFE_INTEGER will suffer from loss of precision and make Number.isInteger return true even when it’s not an integer. (The actual threshold varies based on how many bits are needed to represent the decimal — for example, Number.isInteger(4500000000000000.1) is true , but Number.isInteger(4500000000000000.5) is false .)

Examples

Using isInteger

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

Specifications

Browser compatibility

BCD tables only load in the browser

See also

Found a content problem with this page?

This page was last modified on Feb 21, 2023 by MDN contributors.

Your blueprint for a better internet.

Источник

Rukovodstvo

статьи и идеи для разработчиков программного обеспечения и веб-разработчиков.

JavaScript: проверьте, является ли переменная числом

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

Вступление

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

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

Строки, содержащие числа вроде «10», не принимаются. В JavaScript специальные значения, такие как NaN , Infinity и -Infinity , тоже являются числами, однако мы будем игнорировать эти значения.

С учетом этих требований лучше всего использовать функцию isFinite() из встроенного объекта Number

Однако разработчики обычно использовали для этой цели другие функции, в частности Number.isNaN() и функцию typeof()

Создадим несколько переменных для тестирования:

 let intVar = 2; let floatVar = 10.5; let stringVar = '4'; let nanVar = NaN; let infinityVar = Infinity; let nullVar = null; let undefinedVar = undefined; 

Использование функции Number.isFinite ()

Функция Number.isFinite() проверяет, является ли переменная числом, но также проверяет, является ли это конечным значением. Следовательно, он возвращает false для чисел NaN , Infinity или -Infinity .

Давайте проверим это на переменных, которые мы определили выше:

 > Number.isFinite(intVar); true > Number.isFinite(floatVar); true > Number.isFinite(stringVar); false > Number.isFinite(nanVar); false > Number.isFinite(infinityVar); false > Number.isFinite(nullVar); false > Number.isFinite(undefined); false 

Это именно то, что мы хотели. Специальные нефинитные числа игнорируются, как и любые переменные, не являющиеся числовыми.

Если вы хотите проверить, является ли переменная числом, лучше всего использовать Number.isFinite() .

Использование функции Number.isNaN ()

Стандартный объект Number имеет метод isNaN() Он принимает один аргумент и определяет, равно ли его значение NaN . Поскольку мы хотим проверить, является ли переменная числом, мы будем использовать оператор not ! , в наших чеках.

Теперь проверим, могут ли оператор not и Number.isNaN() фильтровать только числа:

 > !Number.isNaN(intVar); true > !Number.isNaN(floatVar); true > !Number.isNaN(stringVar); true # Wrong > !Number.isNaN(nanVar); false > !Number.isNaN(infinityVar); true # Wrong > !Number.isNaN(nullVar); true # Wrong > !Number.isNaN(undefinedVar); true # Wrong 

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

Использование функции typeof ()

Функция typeof() — это глобальная функция, которая принимает переменную или значение в качестве аргумента и возвращает строковое представление своего типа. Всего у JavaScript 9 типов:

• undefined
• boolean
• number
• string
• bigint
• symbol
• object
• null ( typeof() отображается как объект)
• function (особый тип объекта)

Чтобы проверить, является ли переменная числом, нам просто нужно проверить, является ли значение, возвращаемое typeof() , «number» . Давайте попробуем это на тестовых переменных:

 > typeof(intVar) == 'number'; true > typeof(floatVar) == 'number'; true > typeof(stringVar) == 'number'; false > typeof(nanVar) == 'number'; true # Wrong > typeof(infinityVar) == 'number'; true # Wrong > typeof(nullVar) == 'number'; false > typeof(undefined) == 'number'; false 

Функция typeof() работает намного лучше, чем Number.isNaN() . Он правильно определяет, что строковая переменная, null и undefined не являются числами. Однако он возвращает true для NaN и Infinity .

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

Заключение

В этой статье мы узнали, как проверить, является ли переменная в JavaScript числом. Функция Number.isNaN() подходит только в том случае, если мы знаем, что наша переменная является числом, и нам нужно проверить, является ли она конкретно NaN или нет.

Функция typeof() подходит, если ваш код может работать с NaN , Infinity или -Infinity а также с другими числами.

Метод Number.isFinite() захватывает все конечные числа и наиболее соответствует нашим требованиям.

Licensed under CC BY-NC-SA 4.0

Источник