2572

What's the cleanest, most effective way to validate decimal numbers in JavaScript?

Bonus points for:

  1. Clarity. Solution should be clean and simple.
  2. Cross-platform.

Test cases:

01. IsNumeric('-1')      => true
02. IsNumeric('-1.5')    => true
03. IsNumeric('0')       => true
04. IsNumeric('0.42')    => true
05. IsNumeric('.42')     => true
06. IsNumeric('99,999')  => false
07. IsNumeric('0x89f')   => false
08. IsNumeric('#abcdef') => false
09. IsNumeric('1.2.3')   => false
10. IsNumeric('')        => false
11. IsNumeric('blah')    => false
Improve this question
10
  • 274
    Just a note 99,999 is a valid number in France, its the same as 99.999 in uk/ us format, so if you are reading in a string from say an input form then 99,999 may be true. Commented Aug 20, 2008 at 14:31
  • 5
    Also check out this post and the great comments. Commented Nov 23, 2009 at 18:05
  • 82
    Decimal comma is the standard in entire Europe and Russia (except UK) Commented Feb 16, 2011 at 14:29
  • 93
    jQuery 1.7 has introduced the jQuery.isNumeric utility function: api.jquery.com/jQuery.isNumeric Commented Nov 16, 2011 at 20:04
  • 26
    jQuery.isNumeric will fail the OP's seventh test case (IsNumeric('0x89f') => *false*). I'm not sure if I agree with this test case, however. Commented Aug 27, 2012 at 16:42

52 Answers 52

Reset to default
1
2
2

I think my code is perfect ...

/**
 * @param {string} s
 * @return {boolean}
 */
var isNumber = function(s) {
    return s.trim()!=="" && !isNaN(Number(s));
};

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

2

You can minimize this function in a lot of way, and you can also implement it with a custom regex for negative values or custom charts:

$('.number').on('input',function(){
    var n=$(this).val().replace(/ /g,'').replace(/\D/g,'');
    if (!$.isNumeric(n))
        $(this).val(n.slice(0, -1))
    else
        $(this).val(n)
});
Improve this answer

Comments

2

No need to use extra lib.

const IsNumeric = (...numbers) => {
  return numbers.reduce((pre, cur) => pre && !!(cur === 0 || +cur), true);
};

Test

> IsNumeric(1)
true
> IsNumeric(1,2,3)
true
> IsNumeric(1,2,3,0)
true
> IsNumeric(1,2,3,0,'')
false
> IsNumeric(1,2,3,0,'2')
true
> IsNumeric(1,2,3,0,'200')
true
> IsNumeric(1,2,3,0,'-200')
true
> IsNumeric(1,2,3,0,'-200','.32')
true
Improve this answer

Comments

2

I have run the following below and it passes all the test cases...

It makes use of the different way in which parseFloat and Number handle their inputs...

function IsNumeric(_in) {
    return (parseFloat(_in) === Number(_in) && Number(_in) !== NaN);
}
Improve this answer

5 Comments

I haven't tried this, but just a tip: you can reduce that to just return the if expression, e.g. return parseFloat...
@Michael Haren, silly me, I just saw this link http://dl.dropboxusercontent.com/u/35146/js/tests/isNumber.html in the highest upvote(the one about 30+ test cases), explains a lot...
This is wrong, you cannot compare against NaN with ==, ===, !=, or !==, it always returns false.
The tricky thing about NaN is that it is unequal to every JavaScript value, including itself. So anythingAtAll === NaN is false and anythingAtAll !== NaN is true. The way you test for NaN is to compare a value to itself: x !== x is true if x is NaN, and false otherwise.
@jkdev You can also use isNaN(NaN) which will return true. This is a built-in function to JavaScript. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
2

A simple and clean solution by leveraging language's dynamic type checking:

function IsNumeric (string) {
   if(string === ' '.repeat(string.length)){
     return false
   }
   return string - 0 === string * 1
}

if you don't care about white-spaces you can remove that " if "

see test cases below

function IsNumeric (string) {
   if(string === ' '.repeat(string.length)){
      return false
   }
   return string - 0 === string * 1
}


console.log('-1' + ' → ' + IsNumeric('-1'))    
console.log('-1.5' + ' → ' + IsNumeric('-1.5')) 
console.log('0' + ' → ' + IsNumeric('0'))     
console.log('0.42' + ' → ' + IsNumeric('0.42'))   
console.log('.42' + ' → ' + IsNumeric('.42'))    
console.log('99,999' + ' → ' + IsNumeric('99,999'))
console.log('0x89f' + ' → ' + IsNumeric('0x89f'))  
console.log('#abcdef' + ' → ' + IsNumeric('#abcdef'))
console.log('1.2.3' + ' → ' + IsNumeric('1.2.3')) 
console.log('' + ' → ' + IsNumeric(''))    
console.log('33 ' + ' → ' + IsNumeric('33 '))

Improve this answer

Comments

1

@CMS' answer: Your snippet failed on whitespace cases on my machine using nodejs. So I combined it with @joel's answer to the following:

is_float = function(v) {
    return !isNaN(v) && isFinite(v) &&
        (typeof(v) == 'number' || v.replace(/^\s+|\s+$/g, '').length > 0);
}

I unittested it with those cases that are floats:

var t = [
        0,
        1.2123,
        '0',
        '2123.4',
        -1,
        '-1',
        -123.423,
        '-123.432',
        07,
        0xad,
        '07',
        '0xad'
    ];

and those cases that are no floats (including empty whitespaces and objects / arrays):

    var t = [
        'hallo',
        [],
        {},
        'jklsd0',
        '',
        "\t",
        "\n",
        ' '
    ];

Everything works as expected here. Maybe this helps.

Full source code for this can be found here.

Improve this answer

Comments

1

The following seems to works fine for many cases:

function isNumeric(num) {
    return (num > 0 || num === 0 || num === '0' || num < 0) && num !== true && isFinite(num);
}

This is built on top of this answer (which is for this answer too): https://stackoverflow.com/a/1561597/1985601

Improve this answer

1 Comment

Returns true for '0xF', which is not a decimal number. Depending on the use-case, this may or may not be desirable.
1 
function isNumber(n) {
    return (n===n+''||n===n-0) && n*0==0 && /\S/.test(n);
}

Explanations:

(n===n-0||n===n+'') verifies if n is a number or a string (discards arrays, boolean, date, null, ...). You can replace (n===n-0||n===n+'') by n!==undefined && n!==null && (n.constructor===Number||n.constructor===String): significantly faster but less concise.

n*0==0 verifies if n is a finite number as isFinite(n) does. If you need to check strings that represent negative hexadecimal, just replace n*0==0 by something like n.toString().replace(/^\s*-/,'')*0==0.
It costs a little of course, so if you don't need it, don't use it.

/\S/.test(n) discards empty strings or strings, that contain only white-spaces (necessary since isFinite(n) or n*0==0 return a false positive in this case). You can reduce the number of call to .test(n) by using (n!=0||/0/.test(n)) instead of /\S/.test(n), or you can use a slightly faster but less concise test such as (n!=0||(n+'').indexOf('0')>=0): tiny improvement.

Improve this answer

Comments

1

One can use a type-check library like https://github.com/arasatasaygin/is.js or just extract a check snippet from there (https://github.com/arasatasaygin/is.js/blob/master/is.js#L131):

is.nan = function(value) {    // NaN is number :) 
  return value !== value;
};
 // is a given value number?
is.number = function(value) {
    return !is.nan(value) && Object.prototype.toString.call(value) === '[object Number]';
};

In general if you need it to validate parameter types (on entry point of function call), you can go with JSDOC-compliant contracts (https://www.npmjs.com/package/bycontract):

/**
 * This is JSDOC syntax
 * @param {number|string} sum
 * @param {Object.<string, string>} payload
 * @param {function} cb
 */
function foo( sum, payload, cb ) {
  // Test if the contract is respected at entry point
  byContract( arguments, [ "number|string", "Object.<string, string>", "function" ] );
}
// Test it
foo( 100, { foo: "foo" }, function(){}); // ok
foo( 100, { foo: 100 }, function(){}); // exception
Improve this answer

Comments

1

Best way to do this is like this:

function isThisActuallyANumber(data){
    return ( typeof data === "number" && !isNaN(data) );
}
Improve this answer

Comments

0

I found simple solution, probably not best but it's working fine :)

So, what I do is next, I parse string to Int and check if length size of new variable which is now int type is same as length of original string variable. Logically if size is the same it means string is fully parsed to int and that is only possible if string is "made" only of numbers.

var val=1+$(e).val()+'';
var n=parseInt(val)+'';
if(val.length == n.length )alert('Is int');

You can easily put that code in function and instead of alert use return true if int. Remember, if you use dot or comma in string you are checking it's still false cos you are parsing to int.

Note: Adding 1+ on e.val so starting zero wouldn't be removed.

Improve this answer

Comments

0

With regex we can cover all the cases ask in the question. Here it is:

isNumeric for all integers and decimals:

const isNumeric = num => /^-?[0-9]+(?:\.[0-9]+)?$/.test(num+'');

isInteger for just integers:

const isInteger = num => /^-?[0-9]+$/.test(num+'');
Improve this answer

Comments

0

Need to check for the null/undefined condition and remove commas (for the US number format) if typeof n === 'string'.

function isNumeric(n)
{
    if(n === null || typeof n === 'undefined')
         return false;

    if(typeof n === 'string')
        n = n.split(',').join('');

    return !isNaN(parseFloat(n)) && isFinite(n);
}

https://jsfiddle.net/NickU/nyzeot03/3/

Improve this answer

Comments

0

If you preference is to have your numeric function predictates to be implicitly strict (eg, no parsing of strings), then this should do the trick.

function isNumeric(n, parse) {
    var t = typeof(n);
    if (parse){
        if (t !== 'number' && t !=='string') return false;
        return !isNaN(parseFloat(n)) && isFinite(n);
    }else{
        if (t !== 'number') return false;
        return !isNaN(n) && isFinite(n) && !_.isString(n);
    }
}

function isInteger(n, parse) {    
    return isNumeric(n, parse) && n % 1 === 0;
}

function isFloat(n, parse) {
    return isNumeric(n, parse) && n % 1 !== 0;
}

If you want the code to parse strings, then just pass the true in the parse parameter.

This is modification of underscore-contrib's approach which is to be implicitly loose and try parsing strings and even returns true for isNumeric([1]), which can be a real trap for people. My approach above will also be faster as it only calls parseFloat() when parse = true.

Improve this answer

Comments

0

What about:

    function IsNumeric(input)
    {
        return (Number(String(input)) > -Infinity && String(input)?.length !== 0 && !(/^0x|^0b|^0o/).test(String(input)) ) ? true : false;
    }

    IsNumeric('-1') === true
    IsNumeric('-1.5') === true
    IsNumeric('0') === true
    IsNumeric('0.42') === true
    IsNumeric('.42') === true
    IsNumeric(1.1) === true
    IsNumeric(0) === true
    IsNumeric(8e5) === true
    IsNumeric('0x89f') === false // hexadecimal
    IsNumeric('0b10') === false  // binary
    IsNumeric('0o10') === false  // octal
    IsNumeric('99,999 === false
    IsNumeric('#abcdef') === false
    IsNumeric('1.2.3') === false
    IsNumeric('') === false
    IsNumeric('blah') === false
    IsNumeric(null) === false
    IsNumeric(undefined) === false
    IsNumeric(NaN) === false
Improve this answer

Comments

-1

I use this way to chack that varible is numeric:

v * 1 == v
Improve this answer

1 Comment

Problem: false * 1 == false evaluates to true.
-1 
function isNumeric(n) {
    var isNumber = true;

    $.each(n.replace(/ /g,'').toString(), function(i, v){
        if(v!=',' && v!='.' && v!='-'){
            if(isNaN(v)){
               isNumber = false;
               return false;
            }
         }
     });

    return isNumber;
}

isNumeric(-3,4567.89);   // true <br>

isNumeric(3,4567.89);   // true <br>

isNumeric("-3,4567.89");   // true <br>

isNumeric(3d,4567.89);   // false
Improve this answer

Comments

-1 
$('.rsval').bind('keypress', function(e){  
        var asciiCodeOfNumbers = [48,46, 49, 50, 51, 52, 53, 54, 54, 55, 56, 57];
        var keynum = (!window.event) ? e.which : e.keyCode; 
        var splitn = this.value.split("."); 
        var decimal = splitn.length;
        var precision = splitn[1]; 
        if(decimal == 2 && precision.length >= 2  ) { console.log(precision , 'e');   e.preventDefault(); } 
        if( keynum == 46 ){  
            if(decimal > 2) { e.preventDefault(); }  
        } 
        if ($.inArray(keynum, asciiCodeOfNumbers) == -1)
            e.preventDefault();    
  });
Improve this answer

Comments

-2

@Zoltan Lengyel 'other locales' comment (Apr 26 at 2:14) in @CMS Dec answer (2 '09 at 5:36):

I would recommend testing for typeof (n) === 'string':

    function isNumber(n) {
        if (typeof (n) === 'string') {
            n = n.replace(/,/, ".");
        }
        return !isNaN(parseFloat(n)) && isFinite(n);
    }

This extends Zoltans recommendation to not only be able to test "localized numbers" like isNumber('12,50') but also "pure" numbers like isNumber(2011).

Improve this answer

Comments

-3

Well, I'm using this one I made...

It's been working so far:

function checkNumber(value) {
    if ( value % 1 == 0 )
        return true;
    else
        return false;
}

If you spot any problem with it, tell me, please.

Like any numbers should be divisible by one with nothing left, I figured I could just use the module, and if you try dividing a string into a number the result wouldn't be that. So.

Improve this answer

1 Comment

What about 1.5? Also, the function's body has a lot of redundant code. You should directly return the expression's result, which will be a Boolean.
-3

Here I've collected the "good ones" from this page and put them into a simple test pattern for you to evaluate on your own.

For newbies, the console.log is a built in function (available in all modern browsers) that lets you output results to the JavaScript console (dig around, you'll find it) rather than having to output to your HTML page.

var isNumeric = function(val){
    // --------------------------
    // Recommended
    // --------------------------

    // jQuery - works rather well
    // See CMS's unit test also: http://dl.getdropbox.com/u/35146/js/tests/isNumber.html
    return !isNaN(parseFloat(val)) && isFinite(val);

    // Aquatic - good and fast, fails the "0x89f" test, but that test is questionable.
    //return parseFloat(val)==val;

    // --------------------------
    // Other quirky options
    // --------------------------
    // Fails on "", null, newline, tab negative.
    //return !isNaN(val);

    // user532188 - fails on "0x89f"
    //var n2 = val;
    //val = parseFloat(val);
    //return (val!='NaN' && n2==val);

    // Rafael - fails on negative + decimal numbers, may be good for isInt()?
    // return ( val % 1 == 0 ) ? true : false;

    // pottedmeat - good, but fails on stringy numbers, which may be a good thing for some folks?
    //return /^-?(0|[1-9]\d*|(?=\.))(\.\d+)?$/.test(val);

    // Haren - passes all
    // borrowed from http://www.codetoad.com/javascript/isnumeric.asp
    //var RE = /^-{0,1}\d*\.{0,1}\d+$/;
    //return RE.test(val);

    // YUI - good for strict adherance to number type. Doesn't let stringy numbers through.
    //return typeof val === 'number' && isFinite(val);

    // user189277 - fails on "" and "\n"
    //return ( val >=0 || val < 0);
}

var tests = [0, 1, "0", 0x0, 0x000, "0000", "0x89f", 8e5, 0x23, -0, 0.0, "1.0", 1.0, -1.5, 0.42, '075', "01", '-01', "0.", ".0", "a", "a2", true, false, "#000", '1.2.3', '#abcdef', '', "", "\n", "\t", '-', null, undefined];

for (var i=0; i<tests.length; i++){
    console.log( "test " + i + ":    " + tests[i] + "    \t   " + isNumeric(tests[i]) );
}
Improve this answer

Comments

-4

The following may work as well.

function isNumeric(v) {
         return v.length > 0 && !isNaN(v) && v.search(/[A-Z]|[#]/ig) == -1;
   };
Improve this answer

Comments

1
2

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.