How to check if a scalar value is numeric or string?

[bgupta]

Hi Monks, I am trying to distinguish between numeric and string scalar values using regular expression as the below code.

my $var = {
            'key1' => '1',
            'key2' => 1
          };
print "Key1: It is a number\n" if ( $var->{'key1'} =~ /^-?\d/ ) ;
print "Key2: It is a number\n" if ( $var->{'key2'} =~ /^-?\d/ ) ;

But it is always getting interpreted as a number. Could somebody help me distinguish between the values '1' and 1 as in the above code

[ikegami]

But it is always getting interpreted as a number.

Actually, they're both getting interpreted as strings. The regex match operator only works on strings, so if it's operand isn't a string, it automatically converts the operand to a string.

Then you use the match operator to check if the string contains something that looks like a number. And since it does, you print your message.

As for the answer to your question, Perl doesn't see the difference you see. If it needs a string, it automatically converts the number into a string (and the variable then holds both a number and a string). If it needs a number, it automatically converts the string into a number (and the variable then holds both a number and a string). It has no compunction against doing so on a while, even for constants.

[biohisham]

I tried to do it using regular expressions but I couldn't have a clear shot, there is another feature, use the complement operator, In order to determine if a variable is a number or a string, employ the principle that &ing a variable with its complement should give 0 as a result if that variable holds a number, whereas it is not the case when that variable is a string.

try extending on this principle, here is a snippet:

my $x=111;
my $y="111";

print "\$x is a number\n" if !($x & ~$x);
print "\$y is a string\n" if ($y & ~$y);

[ikegami]

By the way, $x & ~$x can also be written as $x ^ $x.

[Anonymous Monk]

As of perl 5.24 you can no longer use this trick because ^ does not like strings with code points over 0xFF. Right now it is deprecated, but will presumably be fatal later.

[bgupta]

Many thanks, you saved my day, this approach works perfectly for me.

[ig]

But watch out for side effects.

my $x = 1;
my $y = '1';

print "x is a ", (($x ^ $x)?"string":"number"), "\n";
print "y is a ", (($y ^ $y)?"string":"number"), "\n";

print "\$x = $x\n";
print "\$y = $y\n";

print "x is a ", (($x ^ $x)?"string":"number"), "\n";
print "y is a ", (($y ^ $y)?"string":"number"), "\n";

my $z = $x + $y;

print "\$z = $z\n";

print "x is a ", (($x ^ $x)?"string":"number"), "\n";
print "y is a ", (($y ^ $y)?"string":"number"), "\n";

gives

x is a number
y is a string
$x = 1
$y = 1
x is a number
y is a string
$z = 2
x is a number
y is a number

It might be better to revise your program so that it doesn't depend on such a subtle distinction.

[SuicideJunkie]

There is no practical difference between the values of '1' and 1. You could possibly dig into the guts of SVs and test whether your variable has been used as a number/string yet, but that would be a lot of work for questionable gains.

The real (XY problem) question is; why do you care? Perl will give you a string where appropriate (concatenation operation, say), and a number where appropriate (eg: addition operation)

[james2vegas]

The looks_like_number function in Scalar::Util would tell you if Perl thinks your scalar is numeric.

Update: Ok, guess not that, what is your need for this functionality? Strings that look like numbers and numbers are generally interchangeable.

[JavaFan]

Generally, yes. In a few cases, there's a difference. Binary bit operators, for instance.

  say "12" | "34";  # 36
  say  12  |  34;   # 46

And you might think the following code won't give you a divide by zero error:

if ($num && $num =~ /^[0-9]+$/) {say 1/$num}

but it will if $num eq '00'.

Devel::Peek is a tool that can tell you whether scalar holds a numeric value or not (look for the IV and NV flags).

[bgupta]

Actually the exact requirement is as below:

1. Use GetOptions to process the input command line.
2. Do the required validation. This will result in modifying the command line paramteres
   and resultant will be stored in a hash.
3. Use this hash in order to form the command line again.

The problem is while doing the 3rd step, I need to distinguish if a given argument is a toggle or a parameter. So, I want to distinguish between 1( toggle ) and '1'( argument ).

[ikegami]

Why don't you save a copy of the command line before calling GetOptions?

If you can't because you're rearranging the command line somehow, you'll need to pass your reconstructor some of the information you pass to GetOptions (as in, whether a parameter is a toggle or takes a value).

[bv]

Your requirement mentions GetOptions. Does this mean you are using Getopt::Long? If so, how are you specifying the option? opt=s, opt:s, opt=i, opt:i, opt, etc?

Getopt::Long is usually good about setting sane values. If you asked for an integer with :i, it will set your value to 0 if there was no argument given, so you can test with exists to see if it was set.

[GrandFather]

If you know at the point where you store the value that it is a 1 or a '1', then store '1' (including the quote marks) for the string version.

[bluestar]

This should give you a fairly accurate answer i.e. suppress warnings locally and compare the value to itself after adding a numeric value to it.

use strict;
use warnings;

my $integer = 777;
my $string  = 'hello';
my $float   = 3.22 + 4.34;

print _isNumeric($integer) . "\n";
print _isNumeric($string) . "\n";
print _isNumeric($float) . "\n";

sub _isNumeric {
        my ($value) = @_; 

        no warnings;

        return 1 if ($value + 0) eq $value;
        return 0;
}

[ikegami]

That's a pretty good reimplementation of looks_like_number, but it doesn't answer the OP's question. He still gets the same answer he currently gets.

sub _isNumeric {
        my ($value) = @_; 

        no warnings;

        return 1 if ($value + 0) eq $value;
        return 0;
}

my $var = {
            'key1' => '1',
            'key2' => 1
          };
print "Key1: It is a number\n" if _isNumeric( $var->{'key1'} ) ;
print "Key2: It is a number\n" if _isNumeric( $var->{'key2'} ) ;

Key1: It is a number
Key2: It is a number

[syphilis]

There may be a module that already implements this:

use warnings;

use Inline C => Config =>
    BUILD_NOISY => 1;

use Inline C => <<'EOC';

SV* wotisit(SV * arg) {
  if(SvPOK(arg)) return newSVpv("string", 0);
  if(SvIOK(arg) || SvNOK(arg) || SvUOK(arg))
     return newSVpv("number", 0);
  return newSVpv("something else", 0);
}

EOC
use Math::BigInt; # for testing
my $o = Math::BigInt->new(0);

for('1', '1.1', 1, 1.1, $o) {
   print wotisit($_), "\n";
}

Outputs:

string
string
number
number
something else

Cheers,
Rob

[ibravos]

Thanks to the sugestions above i have the function isnum:

sub isnum ($) { $_[0] ^ $_[0] ? 0 : 1 }

XORing a number gives zero, so the function returns 1. XORing a string gives a string of nulls, still a non-empty string, so the function returns 0

[ibravos]

Correction: isnum('') returns 1, so here is a better version

sub isnum ($) {
    return 0 if $_[0] eq '';
    $_[0] ^ $_[0] ? 0 : 1
}