I'm sure you have your reasons for wanting to do this with a regular expression , but surely the smart way to do it would be:

   $number >= 0 and $number <= 255
[download]

/J\

Thanks for the reply. Actually I have other people's reasons for having to do this with a regexp. The regexp is an attribute in an XML file, which is at some point read by a Perl script.

loris

Of course, with 5.9.2, there is a much nicer way to construct an efficient regular expression to match the numbers from 0 to 255 without leading zeroes:

use strict;
my $zero_to_255 = join "|", 0..255;
$zero_to_255 = qr(^(?:$zero_to_255)$);
print $zero_to_255,"\n";
for (-2,-1, 0..259) {
  print "$_\n" 
    unless /$zero_to_255/;
};
[download]

So, stringing together a somewhat large number of static ORs in a regular expression is efficient?

• Programmer wise, I agree.
• Space wise, not so much.
• Time wise? If it is, it is counter intuitive to me...
-Scott

Please note that I mentioned 5.9.2, the most current release of the developer branch, which has a patch by demerphq, that builds a very optimized tree out of a list like mine. The tree (actually a Trie) can the optimally match/compare against the string, by looking at exactly the first three chars of the string and quickly decide if it matches or not.

my $re =qr/
^(\d{1,3})$                             # Up to 3 digits
(?(?{ ($1<256 and $1>=0) })     # If in the correct range
                .?                      # An allways match
        |                       # Else
                .                       # Never going to match after e
+nd of string
)
/x;
[download]

You don't need to test against zero. Or put anything in the success-pattern; an empty pattern matches just fine.

/^(\d{1,3})$(?(?{$1<256 }) | . )/x
[download]

or you could move your anchor and use an impossible anchor for the fail-pattern:

/^(\d{1,3})(?(?{$1<256 }) $ | ^ )/x
[download]

---

Caution: Contents may have been coded under pressure.

I tend to use (?!) for the always fail pattern (there are no positions that aren't followed by the empty string). ^ might match if a /m flag is in use, or if the zero-width assertion is done at the beginning of the string. An empty string works fine as an always match pattern - or (?=) if you want to go symmetric.

use strict;
use warnings;

my @nums;
for(my $i = -100; $i < 400; $i++)
{
    push @nums, $i;
}

foreach my $n (@nums)
{
    if($n =~ /^[012]?(((?<=2)[0-5])|(?<!2)[0-9])?(((?<=25)[0-5])|(?<!2
+5)[0-9])$/)
    {
        print $n, ": pass\n";
    }
    else
    {
        print $n, ": fail\n";
    }
}
[download]

This reads a little nicer, but I don't know whether you'd consider it cheating. It's a Perl regex:

/^(\d{1,3})${\($1 > 255 ? qr(^) : qr($))}/
[download]

Update: meant to link to the post, not the poster. So now "solutions in this vein" links to the post.

Hey! I've just noticed you're calling me "experimental feature".
Thanks!! =oD

That doesn't work. Interpolation happens before the regex is performed, so your $1 refers to a previous succesful match:

#!/usr/bin/perl

use strict;
use warnings;

while (<DATA>) {
    chomp;
    printf "%d %s\n", $_, /^(\d{1,3})${\($1 > 255 ? qr(^) : qr($))}/
         ? "matches" : "fails";
}

__DATA__
3
100
333
200


Use of uninitialized value in numeric gt (>) at XXX line 9, <DATA> lin
+e 1.
3 matches
100 matches
333 matches
200 fails
[download]

Yes, I've had a notice to that effect at the top of the post for about an hour.

---

Caution: Contents may have been coded under pressure.

use strict;
use warnings;

my @nums = (100,-3,150,-2,-1,256, 280, 254);;

foreach my $n (@nums)
{
    print "$n: ",
    ($n !~ /^1?\d{1,2}$|^2(?:[0-4]\d|5[0-5])$/)
    ? 'fail' : 'pass';
}
[download]

That would match: "1\N{TIBETAN DIGIT ONE}\N{TIBETAN DIGIT ONE}", but not "\N{TIBETAN DIGIT ONE}1\N{TIBETAN DIGIT ONE}". Doesn't seem fair to the Dalai Lama to me!

You need to use use charnames ':full' to use \N in the way presented.