Validate that a string is a positive integer

Question

I would like the simplest fail-safe test to check that a string in JavaScript is a positive integer   isNaN str  returns true for all sorts of non-integer values and parseInt str  is returning integers for float strings  like  2 5   And I don t want to have to use some jQuery plugin either

User · Answer

Solution 1

If we consider a JavaScript integer to be a value of maximum 4294967295 (i.e. Math.pow(2,32)-1), then the following short solution will perfectly work:

function isPositiveInteger(n) {
    return n >>> 0 === parseFloat(n);
}

DESCRIPTION:

Zero-fill right shift operator does three important things:
- truncates decimal part
  - 123.45 >>> 0 === 123
- does the shift for negative numbers
  - -1 >>> 0 === 4294967295
- "works" in range of MAX_INT
  - 1e10 >>> 0 === 1410065408
  - 1e7 >>> 0 === 10000000
parseFloat does correct parsing of string numbers (setting NaN for non numeric strings)

TESTS:

"0"                     : true
"23"                    : true
"-10"                   : false
"10.30"                 : false
"-40.1"                 : false
"string"                : false
"1234567890"            : true
"129000098131766699.1"  : false
"-1e7"                  : false
"1e7"                   : true
"1e10"                  : false
"1edf"                  : false
" "                     : false
""                      : false

DEMO: http://jsfiddle.net/5UCy4/37/

Solution 2

Another way is good for all numeric values which are valid up to Number.MAX_VALUE, i.e. to about 1.7976931348623157e+308:

function isPositiveInteger(n) {
    return 0 === n % (!isNaN(parseFloat(n)) && 0 <= ~~n);
}

DESCRIPTION:

!isNaN(parseFloat(n)) is used to filter pure string values, e.g. "", " ", "string";
0 <= ~~n filters negative and large non-integer values, e.g. "-40.1", "129000098131766699";
(!isNaN(parseFloat(n)) && 0 <= ~~n) returns true if value is both numeric and positive;
0 === n % (...) checks if value is non-float -- here (...) (see 3) is evaluated as 0 in case of false, and as 1 in case of true.

TESTS:

"0"                     : true
"23"                    : true
"-10"                   : false
"10.30"                 : false
"-40.1"                 : false
"string"                : false
"1234567890"            : true
"129000098131766699.1"  : false
"-1e10"                 : false
"1e10"                  : true
"1edf"                  : false
" "                     : false
""                      : false

DEMO: http://jsfiddle.net/5UCy4/14/

The previous version:

function isPositiveInteger(n) {
    return n == "0" || ((n | 0) > 0 && n % 1 == 0);
}

DEMO: http://jsfiddle.net/5UCy4/2/

User · Answer

Looks like a regular expression is the way to go   var isInt         d    test  the string

User · Answer

This is how I validate that a string is a positive integer   x000D   x000D  var str    123   var str1    1 5   var str2    -123    console log  is str positive integer     Number isInteger Number str    amp  amp  Number str   gt  0  console log  is str1 positive integer     Number isInteger Number str1    amp  amp  Number str1   gt  0  console log  is str2 positive integer     Number isInteger Number str2    amp  amp  Number str2   gt  0  x000D   x000D   x000D

User · Answer

ES6  Number isInteger Number theNumberString    gt  0

User · Answer

a    a  where a is the string

User · Answer

This is almost a duplicate question fo this one   Validate decimal numbers in JavaScript - IsNumeric    It s answer is   function isNumber n      return  isNaN parseFloat n    amp  amp  isFinite n       so  a positive integer would be   function isPositiveInteger n      var floatN   parseFloat n     return  isNaN floatN   amp  amp  isFinite n   amp  amp  floatN  gt  0        amp  amp  floatN   1    0

User · Answer

If you are using HTML5 forms  you can use attribute min  0  for form element  lt input type  number    gt   This is supported by all major browsers  It does not involve Javascript for such simple tasks  but is integrated in new html standard  It is documented on https   www w3schools com tags att input min asp

User · Answer

My function checks if number is  ve and could be have decimal value as well          function validateNumeric numValue               var value   parseFloat numValue               if   numValue toString   match    -   d     d                           return false              else if  numValue  lt  0                    return false                            return true

User · Answer

Two answers for you    Based on parsing Regular expression   Note that in both cases  I ve interpreted  positive integer  to include 0  even though 0 is not positive  I include notes if you want to disallow 0   Based on Parsing  If you want it to be a normalized decimal integer string over a reasonable range of values  you can do this   function isNormalInteger str        var n   Math floor Number str        return n     Infinity  amp  amp  String n      str  amp  amp  n  gt   0      or if you want to allow whitespace and leading zeros   function isNormalInteger str        str   str trim        if   str            return false            str   str replace   0            0       var n   Math floor Number str        return n     Infinity  amp  amp  String n      str  amp  amp  n  gt   0      Live testbed  without handling leading zeros or whitespace     x000D   x000D  function isNormalInteger str    x000D      var n   Math floor Number str    x000D      return n     Infinity  amp  amp  String n      str  amp  amp  n  gt   0  x000D    x000D  function gid id    x000D      return document getElementById id   x000D    x000D  function test str  expect    x000D      var result   isNormalInteger str   x000D      console log  x000D          str          x000D           result    Yes     No     x000D           expect     undefined          expect       result      lt   OK       lt   ERROR       x000D         x000D    x000D  gid  btn   addEventListener  x000D       click   x000D      function     x000D          test gid  text   value   x000D         x000D      false x000D     x000D  test  1   true   x000D  test  1 23   false   x000D  test  1234567890123   true   x000D  test  1234567890123 1   false   x000D  test  0123   false      false because we don t handle leading 0s x000D  test   123    false      false because we don t handle whitespace x000D   lt label gt  x000D    String  x000D     lt input id  text  type  text  value    gt  x000D   lt label gt  x000D   lt input id  btn  type  button  value  Check  gt  x000D   x000D   x000D    Live testbed  with handling for leading zeros and whitespace     x000D   x000D  function isNormalInteger str    x000D      str   str trim    x000D      if   str    x000D          return false  x000D        x000D      str   str replace   0            0   x000D      var n   Math floor Number str    x000D      return String n      str  amp  amp  n  gt   0  x000D    x000D  function gid id    x000D      return document getElementById id   x000D    x000D  function test str  expect    x000D      var result   isNormalInteger str   x000D      console log  x000D          str          x000D           result    Yes     No     x000D           expect     undefined          expect       result      lt   OK       lt   ERROR       x000D         x000D    x000D  gid  btn   addEventListener  x000D       click   x000D      function     x000D          test gid  text   value   x000D         x000D      false x000D     x000D  test  1   true   x000D  test  1 23   false   x000D  test  1234567890123   true   x000D  test  1234567890123 1   false   x000D  test  0123   true   x000D  test   123    true   x000D   lt label gt  x000D    String  x000D     lt input id  text  type  text  value    gt  x000D   lt label gt  x000D   lt input id  btn  type  button  value  Check  gt  x000D   x000D   x000D    If you want to disallow 0  just change  gt   0 to  gt  0   Or  in the version that allows leading zeros  remove the     0  on the replace line    How that works    In the version allowing whitespace and leading zeros    str   str trim    removes any leading and trailing whitepace  if   str  catches a blank string and returns  no point in doing the rest of the work  str   str replace   0            0   removes all leading 0s from the string nbsp  mdash  but if that results in a blank string  restores a single 0   Number str   Convert str to a number  the number may well have a fractional portion  or may be NaN  Math floor  Truncate the number  chops off any fractional portion   String       Converts the result back into a normal decimal string  For really big numbers  this will go to scientific notation  which may break this approach   I don t quite know where the split is  the details are in the spec  but for whole numbers I believe it s at the point you ve exceeded 21 digits  by which time the number has become very imprecise  as IEEE-754 double-precision numbers only have roughtly 15 digits of precision            str  Compares that to the original string  n  gt   0  Check that it s positive    Note that this fails for the input   1   any input in scientific notation that doesn t turn back into the same scientific notation at the String      stage  and for any value that the kind of number JavaScript uses  IEEE-754 double-precision binary floating point  can t accurately represent which parses as closer to a different value than the given one  which includes many integers over 9 007 199 254 740 992  for instance  1234567890123456789 will fail   The former is an easy fix  the latter two not so much   Regular Expression  The other approach is to test the characters of the string via a regular expression  if your goal is to just allow  say  an optional   followed by either 0 or a string in normal decimal format   function isNormalInteger str        return       0  1-9  d     test str       Live testbed    x000D   x000D  function isNormalInteger str    x000D      return       0  1-9  d     test str   x000D    x000D  function gid id    x000D      return document getElementById id   x000D    x000D  function test str  expect    x000D      var result   isNormalInteger str   x000D      console log  x000D          str          x000D           result    Yes     No     x000D           expect     undefined          expect       result      lt   OK       lt   ERROR       x000D         x000D    x000D  gid  btn   addEventListener  x000D       click   x000D      function     x000D          test gid  text   value   x000D         x000D      false x000D     x000D  test  1   true   x000D  test  1 23   false   x000D  test  1234567890123   true   x000D  test  1234567890123 1   false   x000D  test  0123   false      false because we don t handle leading 0s x000D  test   123    false      false because we don t handle whitespace x000D   lt label gt  x000D    String  x000D     lt input id  text  type  text  value    gt  x000D   lt label gt  x000D   lt input id  btn  type  button  value  Check  gt  x000D   x000D   x000D    How that works       Match start of string      Allow a single  optional    remove this if you don t want to               Allow one of these two options  without creating a capture group      0       Allow 0 on its own          1-9  d       or a number starting with something other than 0 and followed by any number of decimal digits      Match end of string    If you want to disallow 0  because it s not positive   the regular expression becomes just       1-9  d     e g   we can lose the alternation that we needed to allow 0    If you want to allow leading zeroes  0123  00524   then just replace the alternation    0  1-9  d   with  d   function isNormalInteger str        return       d    test str       If you want to allow whitespace  add  s  just after   and  s  just before     Note for when you convert that to a number  On modern engines it would probably be fine to use  str or Number str  to do it  but older ones might extend those in a non-standard  but formerly-allowed  way that says a leading zero means octal  base 8   e g  010     8  Once you ve validated the number  you can safely use parseInt str  10  to ensure that it s parsed as decimal  base 10   parseInt would ignore garbage at the end of the string  but we ve ensured there isn t any with the regex

User · Answer

The modern solution that works in node and across over 90  of all browsers  except IE and Opera Mini  is to use Number isInteger followed by a simple positive check   Number isInteger x   amp  amp  x  gt  0   This was finalized in ECMAScript 2015   function isPositiveInteger x        return Number isInteger x   amp  amp  x  gt  0     The Polyfil is   Number isInteger   Number isInteger    function value      return typeof value      number   amp  amp       isFinite value   amp  amp       Math floor value      value       If you need to support input that might be in string or number form then you can use this function I wrote a large test suite against after all the existing answers  2 1 2018  failed on some form of input   function isPositiveInteger v      var i    return v  amp  amp   i   parseInt v    amp  amp  i  gt  0  amp  amp   i     v       i     v

User · Answer

return   parseInt str  10  toString      str   amp  amp  str indexOf  -       -1     won t work if you give a string like  0001  though

User · Answer

Most of the time you need this type of check for database usage  like checking if string  valid userId  Bacause of that there can t be any strange symbols that can be parced as integer  Also integer should be in database range of integer  You just need normal int like 1 2 3 and so on  const isStrNormPosInt    str  string    gt      return     1-9  d     test str   amp  amp  Number str   lt   2147483647    postgres max int    If check is passed  you can just convert it to number Number str

User · Answer

Just to build on VisioN s answer above  if you are using the jQuery validation plugin you could use this     document  ready function           validator addMethod  integer   function value  element  param            return  value  gt  gt  gt  0     parseFloat value   amp  amp  value  gt  0           Please enter a non zero integer value         Then you could use in your normal rules set or add it dynamically this way       positiveIntegerField   rules  add    required true  integer true

User · Answer

Simple  function isInteger num      return  num   0      num     console log isInteger 1      You can also extend Number and assign the function to it via prototype

[javascript] Validate that a string is a positive integer

Solution 1

Solution 2

Examples related to javascript