# How do I tell if a variable has a numeric value in Perl?

85

Is there a simple way in Perl that will allow me to determine if a given variable is numeric? Something along the lines of:

if (is_number(\$x))
{ ... }

would be ideal. A technique that won't throw warnings when the -w switch is being used is certainly preferred.

This question is tagged with perl numbers

130

Use Scalar::Util::looks_like_number() which uses the internal Perl C API's looks_like_number() function, which is probably the most efficient way to do this. Note that the strings "inf" and "infinity" are treated as numbers.

## Example:

#!/usr/bin/perl

use warnings;
use strict;

use Scalar::Util qw(looks_like_number);

my @exprs = qw(1 5.25 0.001 1.3e8 foo bar 1dd inf infinity);

foreach my \$expr (@exprs) {
print "\$expr is", looks_like_number(\$expr) ? '' : ' not', " a number\n";
}

Gives this output:

1 is a number
5.25 is a number
0.001 is a number
1.3e8 is a number
foo is not a number
bar is not a number
1dd is not a number
inf is a number
infinity is a number

23

The original question was how to tell if a variable was numeric, not if it "has a numeric value".

There are a few operators that have separate modes of operation for numeric and string operands, where "numeric" means anything that was originally a number or was ever used in a numeric context (e.g. in \$x = "123"; 0+\$x, before the addition, \$x is a string, afterwards it is considered numeric).

One way to tell is this:

if ( length( do { no warnings "numeric"; \$x & "" } ) ) {
print "\$x is numeric\n";
}

If the bitwise feature is enabled, that makes & only a numeric operator and adds a separate string &. operator, you must disable it:

if ( length( do { no if \$] >= 5.022, "feature", "bitwise"; no warnings "numeric"; \$x & "" } ) ) {
print "\$x is numeric\n";
}

(bitwise is available in perl 5.022 and above, and enabled by default if you use 5.028; or above.)

23

Check out the CPAN module Regexp::Common. I think it does exactly what you need and handles all the edge cases (e.g. real numbers, scientific notation, etc). e.g.

use Regexp::Common;
if (\$var =~ /\$RE{num}{real}/) { print q{a number}; }

9

Usually number validation is done with regular expressions. This code will determine if something is numeric as well as check for undefined variables as to not throw warnings:

sub is_integer {
defined \$_[0] && \$_[0] =~ /^[+-]?\d+\$/;
}

sub is_float {
defined \$_[0] && \$_[0] =~ /^[+-]?\d+(\.\d+)?\$/;
}

Here's some reading material you should look at.

9

A simple (and maybe simplistic) answer to the question is the content of \$x numeric is the following:

if (\$x  eq  \$x+0) { .... }

It does a textual comparison of the original \$x with the \$x converted to a numeric value.

4

Not perfect, but you can use a regex:

sub isnumber
{
shift =~ /^-?\d+\.?\d*\$/;
}

3

I don't believe there is anything builtin to do it. For more than you ever wanted to see on the subject, see Perlmonks on Detecting Numeric

2

rexep not perfect... this is:

use Try::Tiny;

sub is_numeric {
my (\$x) = @_;
my \$numeric = 1;
try {
use warnings FATAL => qw/numeric/;
0 + \$x;
}
catch {
\$numeric = 0;
};
return \$numeric;
}

2

A slightly more robust regex can be found in Regexp::Common.

It sounds like you want to know if Perl thinks a variable is numeric. Here's a function that traps that warning:

sub is_number{
my \$n = shift;
my \$ret = 1;
\$SIG{"__WARN__"} = sub {\$ret = 0};
eval { my \$x = \$n + 1 };
return \$ret
}

Another option is to turn off the warning locally:

{
no warnings "numeric"; # Ignore "isn't numeric" warning
...                    # Use a variable that might not be numeric
}

Note that non-numeric variables will be silently converted to 0, which is probably what you wanted anyway.

1

I found this interesting though

if ( \$value + 0 eq \$value) {
# A number
push @args, \$value;
} else {
# A string
push @args, "'\$value'";
}

1

Try this:

If ((\$x !~ /\D/) && (\$x ne "")) { ... }

0

You can use Regular Expressions to determine if \$foo is a number (or not).

Take a look here: How do I determine whether a scalar is a number

0

Personally I think that the way to go is to rely on Perl's internal context to make the solution bullet-proof. A good regexp could match all the valid numeric values and none of the non-numeric ones (or vice versa), but as there is a way of employing the same logic the interpreter is using it should be safer to rely on that directly.

As I tend to run my scripts with -w, I had to combine the idea of comparing the result of "value plus zero" to the original value with the no warnings based approach of @ysth:

do {
no warnings "numeric";
if (\$x + 0 ne \$x) { return "not numeric"; } else { return "numeric"; }
}