How can I validate a filename with only eight digits and an extension, in Perl?

Question

Perl (no modules loaded and -Tw & strict) I found much info on regex and pattern matching here but not exactly what I need. I want to know if this is the correct way to validate a couple things. Sorry about the beginner attempt here. I am quite new to this.

my $this = "12345678";

if ($this != m/\b[0-9]{8}\b/x) { print "$this is bad"; }

my $that = "12345678.gif";

if ($that != m/\b[0-9]{8}\.gif\b/x) { print "$that is bad"; }

or

if ($that != m/\b[0-9]{8}\.(jpe?g|gif|png)\b/x) { print "$that is bad"; }


my ($ext) = $that =~ m/\.([^\.]+)$/x;

# verify extension
if  ($ext != m/\.(jpe?g|png|gif)$/x ){ print "$ext is bad"; }

# for content type
if ($ext eq "jpg") {$ext = "jpeg";}

I use the /x because perl::critic indicated I needed it. Passes with /x so...

\d is not an option and should be avoided from what I have read here.

The file name "that" has to be 8 digits + an image type. The other set of digits "this" is actually a folder name. This provides a little error checking for an image serving script. The root htaccess sends calls to images in a specific folder to said script. I grab the directory and image name off via path info.

I appreciating all advice past and present here... I have learned so much.

Answer 1

Most of what you have above looks fine. A few points:

• if ($ext != m/pattern/) is wrong - the != operator should be !~
• \d is just fine, if you're parsing filenames or anything else not likely to be unicode
• avoid /x unless you really need it (you're not splitting the regexp up over multiple lines for readability). For that matter, avoid any of the flags unless you need them
• (jpe?g|gif|png) can be modified to (?:jpe?g|gif|png) to disable capturing on that set of parentheses (the efficiency increase is nominal in most cases, but it occasionally can make a difference e.g. in a rapid loop, so I make it a habit to not capture unless I need to)
• you don't need to escape . inside a character class - i.e. [^\.] can be [^.] (I believe the only character you need to escape is ] itself, but don't take this as gospel) :)
• it's "Perl", not "PERL" :)

Answer 2

If you are running under taint checking, this isn't the way to do it. You need to match the pattern you need then remember that in a memory variable to clear the taint:

my $this = ...;

my $regex = qr/
    ^             # beginning of string
    (             # start of $1
   [0-9]{8}
   \.
   (gif|jpg)   # extension in $2
    )
    \z            #end of string
    /x;

my( $cleansed, $extension ) = do { 
    if( $this =~ m/$regex/ ) { ( $1, $2 ) }
 else                  { die "Bad filename!" }
 };

I'm not sure why you have a \b at the beginning of your regex. It probably doesn't do what you think it does. If you want the file name to be only the digits, use the ^ beginning of string anchor instead. That way, nothing can come before the digits. Likewise, the end of string anchor \z says that nothing can come after the extension.

If you then need to match an extension to a content-type for an HTTP response, which I'm guessing that your doing, you can use a hash to make the map:

 my %types = (
      jpg => jpeg,
      gif => gif,
      ...
      );

Now that you have the hash, you can use it as another level of validation:

 unless( exists $types{$extension} ) { die "Unsupported type!" }

Answer 3

You need to use =~ and !~ instead of == and != for regex matching. Also after removing redundant code and optimizing, I would write it this way.

my $that = "12345678.gif";    
if ($that =~ m/\b[0-9]{8}\.(jpe?g|gif|png)\b/x)
{
    my $ext = $1; 
    if ($ext eq "jpg") {$ext = "jpeg";}
}
else
{
    print "$that is bad";
}