How do I know if a variable is of the Javascript Number type?

Question

In javascript, because there is no declaration of the types of variables such as Integer, String, Boolean, etc., it is a difficult task to know what kind of value you are dealing with in a given variable.

So, to make my code consistent, I would like to know how to proceed to check if a variable is a Numeral or not.

How is this possible?

Answer 1

It is simple to know if a variable is Numero or not because there is a native Javascript operator that says the type of its variable, which would be the operator typeof, there are some types of Javascript variables known:

typeof 0;    //number
typeof 1;    //number
typeof 0.5;  //number

typeof '1';  //string
typeof 'a';  //string
typeof " ";  //string

typeof true; //boolean
typeof false;//boolean

typeof [1,2]         //object
typeof {"obj":[2,3]} //object
typeof {"obj":"3"}   //object

typeof function(){alert('foo')} //function

typeof a    //undefined -- note que nao declarei a
typeof null //null é um object(wtf)

So here’s an example of a function that checks if the type is number

function isNumber(val){
  return typeof val === "number"
}

By testing all the values I exemplified above, you will see that only the ones with type number that I commented will return true.

We can also modify "number" by another type to create a function that checks whether it is string for example, or if it is boolean, it’s that simple.

In fact, it is a disadvantage, depending on the point of view, in Javascript it is not necessary to declare the type and variable before using it.

Answer 2

If you’re not looking to verify something is a number, but if it behaves as if it were, can use this function:

function isNumber(n) {
  return !isNaN(parseFloat(n)) && isFinite(n);
}

The idea is that "1" is, for all intents and purposes, a number. After all you can write "1"+2.

_{Based on a reply by SO CMS.}

Answer 3

Well, Paulo Roberto posted the correct answer - and what he certainly had in mind when he asked the question - to find out if a variable "contains" a number. Some of the other answers have tried to go down the path of finding out if a certain variable "represents" a number; a fairly common problem, and a task that may not be so easy in Javascript (as in most dynamic languages).

While I may be extrapolating the question, since Paul did not mention this point or mark libraries in the question. I think it’s fair to point out that the notorious jQuery has the function jQuery.isNumeric() to solve this second problem of types that may behave as (or be converted to) numbers. When in doubt, between writing regular expressions or combinations of methods isXXX, I believe that it is worth using the library, thus avoiding the various tricks of the language:

Examples of documentation:

$.isNumeric( "-10" );     // true
$.isNumeric( 16 );        // true
$.isNumeric( 0xFF );      // true
$.isNumeric( "0xFF" );    // true
$.isNumeric( "8e5" );     // true (exponential notation string)
$.isNumeric( 3.1415 );    // true
$.isNumeric( +10 );       // true
$.isNumeric( 0144 );      // true (octal integer literal)
$.isNumeric( "" );        // false
$.isNumeric({});          // false (empty object)
$.isNumeric( NaN );       // false
$.isNumeric( null );      // false
$.isNumeric( true );      // false
$.isNumeric( Infinity );  // false
$.isNumeric( undefined ); // false

Answer 4

Javascript has a native function to check if it is not numerical by testing it next to weak typing isNaN.

So if you want to know if it’s numerical you can use !isNaN and it will return true to any numerical value independent of typing.

Example:

!isNaN(1); // true
!isNaN('1'); // true
!isNaN('0'); // true
!isNaN(''); // true (no caso é considerado zero pelo Javascript)
!isNaN(false); // true (no caso é considerado zero pelo Javascript)
!isNaN(true); // true (no caso é considerado um pelo Javascript)

!isNaN('texto'); // false
!isNaN({}); // false

Example of conditional use:

var numero = '12345';
if (!isNaN(numero)) {
    // se é um numero vai cari aqui
}

Which is a compact way of writing that:

if (!isNaN(numero) === true) {
    // se é um numero vai cari aqui
}

// ou (repare que eu removi a negação antes da função)

if (isNaN(numero) === false) {
    // se é um numero vai cari aqui
}

Not to include the value Infinity which is native and can be represented by a string, you can match the function isFinite, example:

!isNaN(numero) && isFinite(numero); // Se for número e não for Infinity vai retornar true

Answer 5

I use the function isNaN, that checks if the variable is not a number and denies it.

var valor = 1.5;
var teste = "a";

console.log(!isNaN(valor)); /* retorna false negando fica true, 1.5 é tipo numérico */
console.log(!isNaN(teste)); /* retorna true negando fica falso, "a" não é um número */

1. http://msdn.microsoft.com/pt-br/library/66ztdbe6(v=vs.94). aspx

UPDATE

You can also convert:

var valor = 1.5;
var teste = "a";
console.log(!!+valor); // é um número
console.log(!!+teste); // não é numero

The + operator in front of the variable tries to convert the variable to number. If it does not give it returns Nan (false), denying twice to get the correct result: false (not number).

Answer 6

The function below tests with regular expression the string passed as parameter and returns true in positive case (string is a number) or false.

function isNumeric(str) {  
     var er = /^[0-9]+$/;  
     return (er.test(str));
} 

source: http://odesenvolvedor.andafter.org/publicacoes/verifica-se-string-numro-no-javascript.html

Answer 7

You refer to checking the type of the value or only if it is numerical?

If you want to know if it is numerical you can check with a regular expression.

The case below accepts the "float" format so to speak, but can be easily adapted to integers or to comma to point fillings:

function isNumeric(value) {

    return /^\d+(?:\.\d+)?$/.test(value);

}