Determine if a string is numeric

Create a boolean function which takes in a string and tells whether it is a numeric string (floating point and negative numbers included) in the syntax the language uses for numeric literals or numbers converted from strings.

ActionScript

<lang actionscript>public function isNumeric(num:String):Boolean {

   return !isNaN(parseInt(num));

}</lang>

Ada

The first file is the package interface containing the declaration of the Is_Numeric function. <lang ada>package Numeric_Tests is

  function Is_Numeric(Item : in String) return Boolean;

end Numeric_Tests;</lang> The second file is the package body containing the implementation of the Is_Numeric function. <lang ada>package body Numeric_Tests is

  ----------------
  -- Is_Numeric --
  ----------------

  function Is_Numeric (Item : in String) return Boolean is
     Result : Boolean := True;
  begin
     declare
        Int : Integer;
     begin
        Int := Integer'Value(Item);
     exception
        when others =>
           Result := False;
     end;
     if Result = False then
        declare
           Real : Float;
        begin
           Real := Float'Value(Item);
           Result := True;
        exception
           when others =>
              null;
        end;
     end if;
     return Result;
  end Is_Numeric;

end Numeric_Tests;</lang> The last file shows how the Is_Numeric function can be called. <lang ada>with Ada.Text_Io; use Ada.Text_Io; with Numeric_Tests; use Numeric_Tests;

procedure Isnumeric_Test is

  S1 : String := "152";
  S2 : String := "-3.1415926";
  S3 : String := "Foo123";

begin

  Put_Line(S1 & " results in " & Boolean'Image(Is_Numeric(S1)));
  Put_Line(S2 & " results in " & Boolean'Image(Is_Numeric(S2)));
  Put_Line(S3 & " results in " & Boolean'Image(Is_Numeric(S3)));

end Isnumeric_Test;</lang> The output of the program above is:

152 results in TRUE
-3.1415926 results in TRUE
Foo123 results in FALSE

ALGOL 68

Translation of: Ada

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

<lang algol68>PROC is numeric = (REF STRING string) BOOL: (

 BOOL out := TRUE;
 PROC call back false = (REF FILE f)BOOL: (out:= FALSE; TRUE);

 FILE memory;
 associate(memory, string);
 on value error(memory, call back false);
 on logical file end(memory, call back false);

 UNION (INT, REAL, COMPL) numeric:=0.0;
 # use a FORMAT pattern instead of a regular expression #
 getf(memory, ($gl$, numeric));
 out

);

test:(

  STRING
    s1 := "152",
    s2 := "-3.1415926",
    s3 := "Foo123";
  print((
    s1, " results in ", is numeric(s1), new line,
    s2, " results in ", is numeric(s2), new line,
    s3, " results in ", is numeric(s3), new line
  ))

) </lang> Output:

152 results in T
-3.1415926 results in T
Foo123 results in F

APL

Works with: Dyalog APL

AutoHotkey

AutoHotkey has no explicitly defined variable types. A variable containing only digits (with an optional decimal point) is automatically interpreted as a number when a math operation or comparison requires it. <lang autohotkey>list = 0 .14 -5.2 ten 0xf Loop, Parse, list, %A_Space%

 MsgBox,% IsNumeric(A_LoopField)

Return

IsNumeric(x) {

 If x is number
   Return, 1
 Else Return, 0

}

Output: 1 1 1 0 1</lang>

AWK

The following function uses the fact that non-numeric strings in AWK are treated as having the value 0 when used in arithmetics, but not in comparison: <lang AWK>$ awk 'func isnum(x){return(x==x+0)}BEGIN{print isnum("hello"),isnum("-42")}' 0 1</lang>

C

Returns true (non-zero) if character-string parameter represents a signed or unsigned floating-point number. Otherwise returns false (zero).

<lang c>#include <stdlib.h> int isNumeric (const char * s) {

   if (s == NULL || *s == '\0')
     return 0;
   char * p;
   strtod (s, &p);
   return *p == '\0';

}</lang>

C++

<lang cpp>#include <sstream> // for istringstream

using namespace std;

bool isNumeric( const char* pszInput, int nNumberBase ) { istringstream iss( pszInput );

if ( nNumberBase == 10 ) { double dTestSink; iss >> dTestSink; } else if ( nNumberBase == 8 || nNumberBase == 16 ) { int nTestSink; iss >> ( ( nNumberBase == 8 ) ? oct : hex ) >> nTestSink; } else return false;

// was any input successfully consumed/converted? if ( ! iss ) return false;

// was all the input successfully consumed/converted? return ( iss.rdbuf()->in_avail() == 0 ); }</lang>

C#

Framework: .NET 2.0+

<lang csharp>public static bool IsNumeric(string s) {

   double Result;
   return double.TryParse(s, out Result);  // TryParse routines were added in Framework version 2.0.

}

string value = "123"; if (IsNumeric(value)) {

 // do something

}</lang>

Framework: .NET 1.0+

<lang csharp>public static bool IsNumeric(string s) {

 try
 {
   Double.Parse(s);
   return true;
 }
 catch
 {
   return false;
 }

}</lang>

Clojure

<lang lisp>(defn numeric? [s]

 (if-let [s (seq s)]
   (let [s (if (= (first s) \-) (next s) s)
         s (drop-while #(Character/isDigit %) s)
         s (if (= (first s) \.) (next s) s)
         s (drop-while #(Character/isDigit %) s)]
     (empty? s))))</lang>

This works with any sequence of characters, not just Strings, e.g.: <lang lisp>(numeric? [\1 \2 \3]) ;; yields logical true</lang>

ColdFusion

Adobe's ColdFusion

 TestValue: <cfoutput>#TestValue#</cfoutput>

 is Numeric.

 is NOT Numeric.

</cfif>

 TestValue: <cfoutput>#TestValue#</cfoutput>

 is Numeric.

 is NOT Numeric.

</cfif></lang>

Common Lisp

If the input may be relied upon to not be malicious, then it may be read and the result checked for being a number. <lang lisp>(defun numeric-string-p (string)

 (numberp (read-from-string string)))</lang>

However, read[-from-string] parses more than just numbers, and some input can have side effects and/or large memory allocation. The parse-number library provides a numbers-only equivalent of read. <lang lisp>(defun numeric-string-p (string)

 (handler-case (progn (parse-number:parse-number string)
                      t)  ; parse succeeded, discard it and return true (t)
   (parse-number::invalid-number ()
     nil)))  ; parse failed, return false (nil)</lang>

D

<lang d>import std.stdio, std.string, std.conv, std.regexp;

bool isNumeric(string s) {

   try
       toDouble(s.strip());
   catch (Error e)
       return false;
   return true;

}

bool isInt(string s) {

   foreach (i, c; s) {
       if (i == 0 && (c == '-' || c == '+'))
           continue;
       if (c >= '0' && c <= '9')
           continue;
       return
           false;
   }
   return true;

}

bool isInt2(string s) {

   return cast(bool)search(s, r"^[-+]?\d+$");

}

bool isInt3(string s) {

   try
       toInt(s.strip());
   catch (Error e)
       return false;
   return true;

}

void main() {

   foreach (s; ["12", " 12\t", "hello12", "-12", "0-12", "+12", "0x10", "6b"]) {
       writefln("isNumeric(", s, ") = ", isNumeric(s));
       writefln("isInt(", s, ") = ", isInt(s));
       writefln("isInt2(", s, ") = ", isInt2(s));
       writefln("isInt3(", s, ") = ", isInt3(s));
       writefln();
   }

}</lang>

E

<lang e>def isNumeric(specimen :String) {

   try {
       <import:java.lang.makeDouble>.valueOf(specimen)
       return true
   } catch _ {
      return false
   }

}</lang>

Erlang

Erlang doesn't come with a way to say if a string represents a numeric value or not, but does come with the built-in function is_number/1, which will return true if the argument passed is either an integer or a float. Erlang also has two functions to transform a string to either a floating number or an integer, which will be used in conjunction with is_number/1.

<lang erlang>is_numeric(L) ->

   Float = (catch erlang:list_to_float(L)),
   Int = (catch erlang:list_to_integer(L)),
   is_number(Float) orelse is_number(Int).</lang>

Factor

<lang factor>: numeric? ( string -- ? ) string>number >boolean ;</lang>

Forth

Works with: gforth version 0.6.2

<lang forth>: is-numeric ( addr len -- )

 2dup snumber? ?dup if      \ not standard, but >number is more cumbersome to use
  0< if
    -rot type ."  as integer = " .
  else
    2swap type ."  as double = " <# #s #> type
  then
 else 2dup >float if
   type ."  as float = " f.
 else
   type ."  isn't numeric in base " base @ dec.
 then then ;

s" 1234" is-numeric \ 1234 as integer = 1234 s" 1234." is-numeric \ 1234. as double = 1234 s" 1234e" is-numeric \ 1234e as float = 1234. s" $1234" is-numeric \ $1234 as integer = 4660 ( hex literal ) s" %1010" is-numeric \ %1010 as integer = 10 ( binary literal ) s" beef" is-numeric \ beef isn't numeric in base 10 hex s" beef" is-numeric \ beef as integer = BEEF s" &1234" is-numeric \ &1234 as integer = 4D2 ( decimal literal )</lang>

Fortran

<lang fortran>FUNCTION is_numeric(string)

 IMPLICIT NONE
 CHARACTER(len=*), INTENT(IN) :: string
 LOGICAL :: is_numeric
 REAL :: x
 INTEGER :: e
 READ(string,*,IOSTAT=e) x
 is_numeric = e == 0

END FUNCTION is_numeric</lang>

Go

<lang go> import "strconv"

func IsNumeric(s string) bool {

   _, err := strconv.Atof(s)
   return err == nil

} </lang>

Groovy

Use the positional parser in java.text.NumberFormat. If, after parsing, the parse position is at the end of the string, we can deduce that the entire string was a valid number. <lang groovy>def isNumeric = {

   def formatter = java.text.NumberFormat.instance
   def pos = [0] as java.text.ParsePosition
   formatter.parse(it, pos)
   
   // if parse position index has moved to end of string
   // them the whole string was numeric
   pos.index == it.size()

}</lang>

Test Program: <lang groovy>println isNumeric('1') println isNumeric('-.555') println isNumeric('1,000,000') println isNumeric(' 1 1 1 1 ') println isNumeric('abcdef')</lang>

Output:

true
true
true
false
false

Haskell

This function is not particularly useful in a statically typed language. Instead, one would just attempt to convert the string to the desired type with read or reads, and handle parsing failure appropriately.

The task doesn't define which strings are considered "numeric", so we do Integers and Doubles, which should catch the most common cases (including hexadecimal 0x notation):

<lang haskell>isInteger s = case reads s :: [(Integer, String)] of

 [(_, "")] -> True
 _         -> False

isDouble s = case reads s :: [(Double, String)] of

 [(_, "")] -> True
 _         -> False

isNumeric :: String -> Bool isNumeric s = isInteger s || isDouble s</lang>

One can easily add isRational, isComplex etc. following the same pattern.

Another way would be to use the Data.Char module, allowing code such as:

<lang haskell>areDigits = all isDigit isDigit selects ASCII digits i.e. '0'..'9' isOctDigit selects '0'..'7' isHexDigit selects '0'..'9','A'..'F','a'..'f'</lang>

so read s::Int (for instance) could be reliably used if string s passed these tests.

HicEst

<lang hicest> ! = bin + 2*int + 4*flt + 8*oct +16*hex + 32*sci

  isNumeric("1001")          ! 27 =  1       1       0       1       1        0
  isNumeric("123")           ! 26 =  0       1       0       1       1        0
  isNumeric("1E78")          ! 48 =  0       0       0       0       1        1
  isNumeric("-0.123")        !  4 =  0       0       1       0       0        1
  isNumeric("-123.456e-78")  ! 32 =  0       0       0       0       0        1
  isNumeric(" 123")          !  0: leading blank
  isNumeric("-123.456f-78")  !  0: illegal character f

FUNCTION isNumeric(string) ! true ( > 0 ), no leading/trailing blanks

  CHARACTER string
  b = INDEX(string, "[01]+", 128, Lbin)                ! Lbin returns length found
  i = INDEX(string, "-?\d+", 128, Lint)                ! regular expression: 128
  f = INDEX(string, "-?\d+\.\d*", 128, Lflt)
  o = INDEX(string, "[0-7]+",    128, Loct)
  h = INDEX(string, "[0-9A-F]+", 128, Lhex)            ! case sensitive: 1+128
  s = INDEX(string, "-?\d+\.*\d*E[+-]*\d*", 128, Lsci)
  IF(anywhere) THEN     ! 0 (false) by default
    isNumeric = ( b > 0 ) + 2*( i > 0 ) + 4*( f > 0 ) + 8*( o > 0 ) + 16*( h > 0 ) + 32*( s > 0 )
  ELSEIF(boolean) THEN  ! 0 (false) by default
    isNumeric = ( b + i + f + o + h + s ) > 0 ! this would return 0 or 1
  ELSE
    L = LEN(string)
    isNumeric = (Lbin==L) + 2*(Lint==L) + 4*(Lflt==L) + 8*(Loct==L) + 16*(Lhex==L) + 32*(Lsci==L)
  ENDIF
END</lang>

IDL

<lang idl>function isnumeric,input

 on_ioerror, false
 test = double(input)
 return, 1
 false: return, 0

end</lang>

Could be called like this:

<lang idl>if isnumeric('-123.45e-2') then print, 'yes' else print, 'no'

==> yes

if isnumeric('picklejuice') then print, 'yes' else print, 'no'

==> no</lang>

Icon and Unicon

Icon

The code writes a printable image of x whatever type it is and a statement about whether it is numeric or not. Icon and Unicon use success and failure instead of boolean functions, numeric(x) is built-in and returns x or fails. <lang Icon> write(image(x), if numeric(x) then " is numeric." else " is not numeric") </lang>

Unicon

This Icon solution works in Unicon.

J

<lang j>isNumeric=: _ ~: _".] isNumericScalar=: [: (*./ *. 0=#@$) isNumeric TXT=: ' is not a number.';' represents a scalar numeric value.' sayIsNumericScalar=: , ;@(TXT{~isNumericScalar)</lang> Examples of use: <lang j> isNumeric '152' 1

  isNumeric '152 -3.1415926 Foo123'

1 1 0

  isNumericScalar '152 -3.1415926 Foo123'

0

  sayIsNumericScalar '-3.1415926'

-3.1415926 represents a scalar numeric value.</lang>

Java

It's generally bad practice in Java to rely on an exception being thrown since exception handling is relatively expensive. If non-numeric strings are common, you're going to see a huge performance hit. <lang java>public boolean isNumeric(String input) {

 try {
   Integer.parseInt(input);
   return true;
 }
 catch (NumberFormatException e) {
   // s is not numeric
   return false;
 }

}</lang>

Alternative 1 : Check that each character in the string is number. Note that this will only works for integers.

<lang java>private static final boolean isNumeric(final String s) {

 if (s == null || s.isEmpty()) return false;
 for (int x = 0; x < s.length(); x++) {
   final char c = s.charAt(x);
   if (x == 0 && (c == '-')) continue;  // negative
   if ((c >= '0') && (c <= '9')) continue;  // 0 - 9
   return false; // invalid
 }
 return true; // valid

}</lang>

Alternative 2 : use a regular expression (a more elegant solution).

<lang java>public static boolean isNumeric(String inputData) {

 return inputData.matches("-?\\d+(.\\d+)?");

}</lang>

Alternative 3 : use the positional parser in the java.text.NumberFormat object (a more robust solution). If, after parsing, the parse position is at the end of the string, we can deduce that the entire string was a valid number.

<lang java>public static boolean isNumeric(String inputData) {

 NumberFormat formatter = NumberFormat.getInstance();
 ParsePosition pos = new ParsePosition(0);
 formatter.parse(inputData, pos);
 return inputData.length() == pos.getIndex();

}</lang>

Alternative 4 : use the java.util.Scanner object. Very useful if you have to scan multiple entries.

<lang java>public static boolean isNumeric(String inputData) {

 Scanner sc = new Scanner(inputData);
 return sc.hasNextInt();

}</lang>

JavaScript

<lang javascript>string value = "123.45e7"; if (isFinite(value)) {

 // do something

} //Or, in web browser in URL box: // javascript:value="123.45e4"; if(isFinite(value)) {alert('numeric')} else {alert('non-numeric')}</lang>

Lisaac

<lang Lisaac>- is_numeric s : ABSTRACT_STRING : BOOLEAN <- (

 + result : BOOLEAN
 + p : NATIVE_ARRAY[CHARACTER];
 ((s != NULL) && {s.count > 0}).if {
   p := s.to_external;
   `strtod(@p, &@p)`;
   result := p.item(0) == '\0'
 };
 result

);</lang>

Logo

<lang logo>show number? "-1.23 ; true</lang>

Lua

This will also accept strings like "0xFF" or "314.16e-2" as numbers. <lang lua>function isNumeric(a)

   return type(tonumber(a)) == "number"

end</lang>

MATLAB

This can be done using several methods in MATLAB. One of the possible ways is given below. An important note, the strings 'i' and 'j' will be recognized as imaginary numbers, not as strings containing the letters 'i' and 'j.' Also, the output of this procedure will be a boolean 0 if the string is a number, or a boolean 1 if it is not.

<lang MATLAB>isempty(str2num('32.10'))

ans =

    0 %Is a numeric string

>> isempty(str2num('jh'))

ans =

    1 %Is a character string

>> isempty(str2num('32i'))

ans =

    0 %Is a numeric string</lang>

MAXScript

<lang maxscript>fn isNumeric str = (

   try
   (
       (str as integer) != undefined
   )
   catch(false)

)

isNumeric "123"</lang>

mIRC Scripting Language

Works with: mIRC

<lang mirc>var %value = 3 if ($1 isnum) {

 echo -s $1 is numeric.

}</lang>

Modula-3

<lang modula3>MODULE Numeric EXPORTS Main;

IMPORT IO, Fmt, Text;

PROCEDURE isNumeric(s: TEXT): BOOLEAN =

 BEGIN
   FOR i := 0 TO Text.Length(s) DO
     WITH char = Text.GetChar(s, i) DO
       IF i = 0 AND char = '-' THEN
         EXIT;
       END;
       IF char >= '0' AND char <= '9' THEN
         EXIT;
       END;
       RETURN FALSE;
     END;
   END;
   RETURN TRUE;
 END isNumeric;

BEGIN

 IO.Put("isNumeric(152) = " & Fmt.Bool(isNumeric("152")) & "\n");
 IO.Put("isNumeric(-3.1415926) = " & Fmt.Bool(isNumeric("-3.1415926")) & "\n");
 IO.Put("isNumeric(Foo123) = " & Fmt.Bool(isNumeric("Foo123")) & "\n");

END Numeric.</lang>

Output:

isNumeric(152) = TRUE
isNumeric(-3.1415926) = TRUE
isNumeric(Foo123) = FALSE

MUMPS

In MUMPS, strings are automatically converted to numbers when a unary or binary arithmetic operator works upon them. If there are no leading digits, a string converts to zero. If there a string of digits followed by an "e" or an "E" followed in turn by more digits, the numbers after the letter are treated as an exponent.

Examples from command line:

USER>WRITE +"1"
1
USER>WRITE +"1A"
1
USER>WRITE +"A1"
0
USER>WRITE +"1E"
1
USER>WRITE +"1E2"
100
USER>WRITE +"1EA24"
1
USER>WRITE +"1E3A"
1000
USER>WRITE +"1E-3"
.001

There is a function, $ISVALIDNUM, to do the testing.

USER>WRITE $SELECT($ISVALIDNUM("123"):"Valid",1:"Invalid"),!
Valid
 
USER>WRITE $SELECT($ISVALIDNUM("a123"):"Valid",1:"Invalid"),!
Invalid
 
USER>WRITE $SELECT($ISVALIDNUM("123a"):"Valid",1:"Invalid"),!
Invalid

USER>WRITE $SELECT($ISVALIDNUM("123e4"):"Valid",1:"Invalid"),!
Valid

Objective-C

Works with: GCC

Works with: OpenStep

Works with: GNUstep

The NSScanner class supports scanning of strings for various types. The scanFloat method will return YES if the string is numeric, even if the number is actually too long to be contained by the precision of a float.

<lang objc>if( [[NSScanner scannerWithString:@"-123.4e5"] scanFloat:NULL] ) NSLog( @"\"-123.4e5\" is numeric" ); else NSLog( @"\"-123.4e5\" is not numeric" ); if( [[NSScanner scannerWithString:@"Not a number"] scanFloat:NULL] ) NSLog( @"\"Not a number\" is numeric" ); else NSLog( @"\"Not a number\" is not numeric" ); // prints: "-123.4e5" is numeric // prints: "Not a number" is not numeric</lang>

The following function can be used to check if a string is numeric "totally"; this is achieved by checking if the scanner reached the end of the string after the float is parsed.

<lang objc>BOOL isNumeric(NSString *s) {

  NSScanner *sc = [NSScanner scannerWithString: s];
  if ( [sc scanFloat:NULL] )
  {
     return [sc isAtEnd];
  }
  return NO;

}</lang>

If we want to scan by hand, we could use a function like the following, that checks if a number is an integer positive or negative number; spaces can appear at the beginning, but not after the number, and the '+' or '-' can appear only attached to the number ("+123" returns YES, but "+ 123" returns NO).

<lang objc>BOOL isNumericI(NSString *s) {

  NSUInteger len = [s length];
  NSUInteger i;
  BOOL status = NO;
  
  for(i=0; i < len; i++)
  {
      unichar singlechar = [s characterAtIndex: i];
      if ( (singlechar == ' ') && (!status) )
      {
        continue;
      }
      if ( ( singlechar == '+' ||
             singlechar == '-' ) && (!status) ) { status=YES; continue; }
      if ( ( singlechar >= '0' ) &&
           ( singlechar <= '9' ) )
      {
         status = YES;
      } else {
         return NO;
      }
  }
  return (i == len) && status;

}</lang>

Here we assumed that in the internal encoding of a string (that should be Unicode), 1 comes after 0, 2 after 1 and so on until 9. Another way could be to get the C String from the NSString object, and then the parsing would be the same of the one we could do in standard C, so this path is not given.

OCaml

This function is not particularly useful in a statically typed language. Instead, one would just attempt to convert the string to the desired type and handle parsing failure appropriately.

The task doesn't define which strings are considered "numeric", so we do ints and floats, which should catch the most common cases:

<lang ocaml>let is_int s =

 try ignore (int_of_string s); true
 with _ -> false

let is_float s =

 try ignore (float_of_string s); true
 with _ -> false

let is_numeric s = is_int s || is_float s</lang>

Octave

The builtin function isnumeric return true (1) if the argument is a data of type number; the provided function isnum works the same for numeric datatype, while if another type is passed as argument, it tries to convert it to a number; if the conversion fails, it means it is not a string representing a number.

<lang octave>function r = isnum(a)

 if ( isnumeric(a) )
   r = 1;
 else
   o = str2num(a);
   r = !isempty(o);
 endif

endfunction

% tests disp(isnum(123)) % 1 disp(isnum("123")) % 1 disp(isnum("foo123")) % 0 disp(isnum("123bar")) % 0 disp(isnum("3.1415")) % 1</lang>

Oz

<lang oz>fun {IsNumeric S}

  {String.isInt S} orelse {String.isFloat S}

end</lang>

Pascal

<lang pascal>function IsNumeric(Value: string; const AllowFloat: Boolean): Boolean; var

 ValueInt: Integer;
 ValueFloat: Extended;
 ErrCode: Integer;

begin // Check for integer: Val only accepts integers when passed integer param Value := SysUtils.Trim(Value); Val(Value, ValueInt, ErrCode); Result := ErrCode = 0; // Val sets error code 0 if OK if not Result and AllowFloat then

   begin
   // Check for float: Val accepts floats when passed float param
   Val(Value, ValueFloat, ErrCode);
   Result := ErrCode = 0;    // Val sets error code 0 if OK
   end;

end;</lang>

Perl

Works with: Perl version 5.8

Quoting from perlfaq4:

How do I determine whether a scalar is a number/whole/integer/float?

Assuming that you don't care about IEEE notations like "NaN" or "Infinity", you probably just want to use a regular expression.

<lang perl>if (/\D/) { print "has nondigits\n" } if (/^\d+$/) { print "is a whole number\n" } if (/^-?\d+$/) { print "is an integer\n" } if (/^[+-]?\d+$/) { print "is a +/- integer\n" } if (/^-?\d+\.?\d*$/) { print "is a real number\n" } if (/^-?(?:\d+(?:\.\d*)?&\.\d+)$/) { print "is a decimal number\n" } if (/^([+-]?)(?=\d&\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/)

                    { print "a C float\n" }</lang>

There are also some commonly used modules for the task. Scalar::Util (distributed with 5.8) provides access to Perl's internal function "looks_like_number" for determining whether a variable looks like a number. Data::Types exports functions that validate data types using both the above and other regular expressions. Thirdly, there is "Regexp::Common" which has regular expressions to match various types of numbers. Those three modules are available from the CPAN.

If you're on a POSIX system, Perl supports the "POSIX::strtod" function. Its semantics are somewhat cumbersome, so here's a "getnum" wrapper function for more convenient access. This function takes a string and returns the number it found, or "undef" for input that isn't a C float. The "is_numeric" function is a front end to "getnum" if you just want to say, Is this a float?

<lang perl>sub getnum {

   use POSIX;
   my $str = shift;
   $str =~ s/^\s+//;
   $str =~ s/\s+$//;
   $! = 0;
   my($num, $unparsed) = strtod($str);
   if (($str eq ) && ($unparsed != 0) && $!) {
       return undef;
   } else {
       return $num;
   }

}

sub is_numeric { defined getnum($_[0]) }</lang>

Or you could check out the String::Scanf module on the CPAN instead. The POSIX module (part of the standard Perl distribution) provides the "strtod" and "strtol" for converting strings to double and longs, respectively.

PHP

PicoLisp

The 'format' function can be used for that. It returns NIL if the given string is not a legal number <lang PicoLisp>: (format "123") -> 123

(format "123a45")

-> NIL

(format "-123.45" 4)

-> 1234500</lang>

PL/I

<lang PL/I> string = '1234ABc';

if verify (string, '0123456789') > 0 then

  put skip list ('string is not numeric');

</lang>

PL/SQL

<lang plsql>FUNCTION IsNumeric( value IN VARCHAR2 ) RETURN BOOLEAN IS

 help NUMBER;

BEGIN

 help := to_number( value );
 return( TRUE );

EXCEPTION

 WHEN others THEN
   return( FALSE );

END;</lang>

<lang plsql>Value VARCHAR2( 10 ) := '123'; IF( IsNumeric( Value ) )

 THEN
   NULL;

END IF;</lang>

PowerShell

Note: PowerShell 1.0 does not support 'try' THis simply tries arithmetic with the argument and if that fails, false is returned. <lang powershell>function isNumeric ($x) {

   try {
       0 + $x | Out-Null
       return $true
   } catch {
       return $false
   }

}</lang>

Alternatively, you can use the static System.Int32.TryParse() method in the .NET framework.

<lang powershell>function isNumeric ($x) {

   $x2 = 0
   $isNum = [System.Int32]::TryParse($x, [ref]$x2)
   return $isNum

}</lang>

PureBasic

This routine parses the string to verify it's a number. It returns 1 if string is numeric, 0 if it is not. The character used as the decimal separator may be specified if desired. <lang PureBasic>Procedure IsNumeric(InString.s, DecimalCharacter.c = '.')

 #NotNumeric = #False
 #IsNumeric = #True
 
 InString = Trim(InString)
 Protected IsDecimal, CaughtDecimal, CaughtE
 Protected IsSignPresent, IsSignAllowed = #True, CountNumeric
 Protected *CurrentChar.Character = @InString
 
 While *CurrentChar\c
   Select *CurrentChar\c
     Case '0' To '9'
       CountNumeric + 1
       IsSignAllowed = #False
     Case DecimalCharacter
       If CaughtDecimal Or CaughtE Or CountNumeric = 0
         ProcedureReturn #NotNumeric
       EndIf
       
       CountNumeric = 0
       CaughtDecimal = #True
       IsDecimal = #True
     Case  '-', '+'
       If IsSignPresent Or Not IsSignAllowed: ProcedureReturn #NotNumeric: EndIf 
       IsSignPresent = #True
     Case 'E', 'e'
       If CaughtE Or CountNumeric = 0
         ProcedureReturn #NotNumeric
       EndIf
       
       CaughtE = #True
       CountNumeric = 0
       CaughtDecimal = #False
       IsSignPresent = #False
       IsSignAllowed = #True
     Default
       ProcedureReturn #NotNumeric
   EndSelect
   *CurrentChar + SizeOf(Character)
 Wend
 
 If CountNumeric = 0: ProcedureReturn #NotNumeric: EndIf
 ProcedureReturn #IsNumeric

EndProcedure

If OpenConsole()

 PrintN("'+3183.31151E+321' = " + Str(IsNumeric("+3183.31151E+321")))
 PrintN("'-123456789' = " + Str(IsNumeric("-123456789")))
 PrintN("'123.45.6789+' = " + Str(IsNumeric("123.45.6789+")))
 PrintN("'-e' = " + Str(IsNumeric("-e")))
 Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
 Input()
 CloseConsole()

EndIf</lang> Sample output:

'+3183.31151E+321' = 1
'-123456789' = 1
'123.45.6789+' = 0
'-e' = 0

Python

<lang python>s = '123' try:

 i = float(s)

except ValueError:

   # not numeric

else:

   # numeric</lang>

Or for positive integers only:

<lang python>s = '123' if s.isdigit():

   # numeric</lang>

Including complex, hex, binary, and octal numeric literals we get: <lang python>def is_numeric(lit):

   'Return value of numeric literal string or ValueError exception'

   # Handle '0'
   if lit == '0': return 0
   # Hex/Binary
   litneg = lit[1:] if lit[0] == '-' else lit
   if litneg[0] == '0':
       if litneg[1] in 'xX':
           return int(lit,16)
       elif litneg[1] in 'bB':
           return int(lit,2)
       else:
           try:
               return int(lit,8)
           except ValueError:
               pass

   # Int/Float/Complex
   try:
       return int(lit)
   except ValueError:
       pass
   try:
       return float(lit)
   except ValueError:
       pass
   return complex(lit)</lang>

Sample use: <lang python>>>> for s in ['0', '00', '123', '-123.', '-123e-4', '0123', '0x1a1', '-123+4.5j', '0b0101', '0.123', '-0xabc', '-0b101']:

   print "%14s -> %-14s %s" % ('"'+s+'"', is_numeric(s), type(is_numeric(s)))

          "0" -> 0              <type 'int'>
         "00" -> 0              <type 'int'>
        "123" -> 123            <type 'int'>
      "-123." -> -123.0         <type 'float'>
    "-123e-4" -> -0.0123        <type 'float'>
       "0123" -> 83             <type 'int'>
      "0x1a1" -> 417            <type 'int'>
  "-123+4.5j" -> (-123+4.5j)    <type 'complex'>
     "0b0101" -> 5              <type 'int'>
      "0.123" -> 0.123          <type 'float'>
     "-0xabc" -> -2748          <type 'int'>
     "-0b101" -> -5             <type 'int'>

>>></lang>

R

<lang R>isnumeric <- function(s) !is.na(as.numeric(s))</lang>

REBOL

<lang REBOL> REBOL [ Title: "Is Numeric?" Author: oofoe Date: 2009-12-04 URL: http://rosettacode.org/wiki/IsNumeric ]

Built-in.

numeric?: func [x][not error? try [to-decimal x]]

Parse dialect for numbers.

pnumeric?: func [x][parse x number]

Test cases.

cases: parse {

  10 -99 
  10.43 -12.04 
  1e99 1.0e10 -10e3 -9.12e7 2e-4 -3.4E-5
  3phase  Garkenhammer  e  n3v3r  phase3

} none foreach x cases [print [x numeric? x pnumeric? x]] </lang>

Ruby

<lang ruby>def isNumeric(s)

 begin
   Float(s)
 rescue
   false # not numeric
 else
   true # numeric
 end

end</lang>

or more compact:

<lang ruby>def isNumeric(s)

   Float(s) != nil rescue false

end</lang>

Scala

Translated from the Groovy and Java examples <lang scala>import java.text.{NumberFormat, ParsePosition}

def isNumeric(input: String): Boolean = {

   val formatter = NumberFormat.getInstance
   val pos = new ParsePosition(0)
   formatter.parse(input, pos)
   input.length == pos.getIndex // valid if parse position is at end of string

}</lang>

Scheme

string->number returns #f when the string is not numeric and otherwise the number, which is non-#f and therefore true. <lang scheme>(define (numeric? s) (string->number s))</lang>

Smalltalk

Works with: GNU Smalltalk

The String class has the method isNumeric; this method (at least on version 3.0.4) does not recognize as number strings like '-123'! So I've written an extension...

<lang smalltalk>String extend [

 realIsNumeric [
    (self first = $+) |
    (self first = $-) 
       ifTrue: [
          ^ (self allButFirst) isNumeric
       ]
       ifFalse: [
          ^ self isNumeric
       ]
 ]

]

{ '1234'. "true"

 '3.14'. '+3.8111'. "true"
 '+45'.             "true"
 '-3.78'.           "true"
 '-3.78.23'. "false"
 '123e3'     "false: the notation is not recognized"

} do: [ :a | a realIsNumeric printNl ]</lang>

SNOBOL4

This task is easy in Snobol. Use the convert( ) function as a predicate returning success (T) or failure (F) for string to real conversion.

<lang Snobol4> define('nchk(str)') :(nchk_end) nchk convert(str,'real') :s(return)f(freturn) nchk_end

# Wrapper for testing

       define('isnum(str)') :(isnum_end)

isnum isnum = 'F'; isnum = nchk(str) 'T'

       isnum = isnum ': ' str :(return)

isnum_end

# Test and display

       output = isnum('123')
       output = isnum('123.0')
       output = isnum('123.')
       output = isnum('-123')
       output = isnum('3.14159')
       output = isnum('1.2.3')
       output = isnum('abc')
       output = isnum('A440')

end</lang>

Output:

T: 123
T: 123.0
T: 123.
T: -123
T: 3.14159
F: 1.2.3
F: abc
F: A440

SQL

Works with: MS SQL version Server 2005

<lang sql>declare @s varchar(10) set @s = '1234.56'

print isnumeric(@s) --prints 1 if numeric, 0 if not.

if isnumeric(@s)=1 begin print 'Numeric' end else print 'Non-numeric'</lang>

Standard ML

<lang sml>(* this function only recognizes integers in decimal format *) fun isInteger s = case Int.scan StringCvt.DEC Substring.getc (Substring.full s) of

  SOME (_,subs) => Substring.isEmpty subs
| NONE          => false

fun isReal s = case Real.scan Substring.getc (Substring.full s) of

  SOME (_,subs) => Substring.isEmpty subs
| NONE          => false

fun isNumeric s = isInteger s orelse isReal s</lang>

Tcl

<lang tcl>if {

   [string is double -strict $varname]

} then { ... }</lang>

Also string is integer (, string is alnum etc etc)

Toka

Returns a flag of TRUE if character-string parameter represents a signed or unsigned integer. Otherwise returns a flag of FALSE. The success or failure is dependent on the source is valid in the current numeric base. The >number function also recognizes several optional prefixes for overriding the current base during conversion.

<lang toka>[ ( string -- flag )

 >number nip ] is isNumeric

( Some tests ) decimal " 100" isNumeric . ( succeeds, 100 is a valid decimal integer ) " 100.21" isNumeric . ( fails, 100.21 is not an integer) " a" isNumeric . ( fails, 'a' is not a valid integer in the decimal base ) " $a" isNumeric . ( succeeds, because $ is a valid override prefix )

                      ( denoting that the following character is a hexadecimal number )</lang>

VBScript

<lang vbscript>IsNumeric(Expr)</lang>

Returns a True if numeric and a false if not.

Visual Basic .NET

Works with: Visual Basic version 2005

<lang vbnet>Dim Value As String = "+123"

If IsNumeric(Value) Then

   PRINT "It is numeric."

End If</lang>

Vedit macro language

This routine returns TRUE if there is numeric value at current cursor location. Only signed and unsigned integers are recognized, in decimal, hex (preceded with 0x) or octal (preceded with 0o). Remove the SUPPRESS option to evaluate an expression instead of single numeric value. <lang vedit>:IS_NUMERIC: if (Num_Eval(SUPPRESS)==0 && Cur_Char != '0') {

   Return(FALSE)

} else {

   Return(TRUE)

}</lang>