RegEx for an invoice format

Question

I'm quite new to regular expressions and I'm trying to create a regex for the validation of an invoice format.

The pattern should be: JjYy (all 4 characters are legit), used 0, 2 or 4 times e.g. no Y's at all is valid, YY is valid, YYYY is valid, but YYY should fail. Followed by a series of 0's repeating 3 to 10 times. The whole should never exceed 10 characters.

examples: JyjY000000 is valid (albeit quite strange) YY000 is valid 000000 is valid jjj000 is invalid jjjj0 is invalid

I learned some basics from here, but my regex fails when it shouldn't. Can someone assist in improving it?

My regex so far is: [JjYy]{0}|[JjYy]{2}|[JjYy]{4}[0]{3,10}.

The following failed also: [JjYy]{0|2|4}[0]{3,10}

Answer 1

How about:

^([JjYy]{2}){0,2}0{3,10}$

To check the length is ten characters or less, use a string length function rather than a regular expression - don't hammer nails with a screwdriver, and so forth.

Test:

#!perl
use warnings;
use strict;

my $re = qr/^([JjYy]{2}){0,2}0{3,10}$/;

my %tests = qw/JyjY000000 valid
           YY000 valid
           000000 valid
           jjj000 invalid
           jjjj0 invalid/;

for my $k (keys %tests) {
    print "$k is ";
    if ($k =~ /$re/) {
        print "valid";
    } else {
        print "invalid";
    }
    print " and it should be $tests{$k}.\n";
}

Produces

jjjj0 is invalid and it should be invalid.
YY000 is valid and it should be valid.
JyjY000000 is valid and it should be valid.
jjj000 is invalid and it should be invalid.
000000 is valid and it should be valid.

Answer 2

([jJyY]{2}){0,2}0{3,10}

If the total length limit is inclusive of the jJyY part, you can check it with a negative look ahead to make sure there are no more than 10 characters in the string to begin with (?![jJyY0]{11,})

\b(?![jJyY0]{11,})([jJyY]{2}){0,2}0{3,10}\b

Answer 3

As you need the total length to never exceed 10 characters I think you have to handle the three kinds of prefixes separately:

0{3,10}|[JjYy]{2}0{3,8}|[JjYy]{4}0{3,6}

Answer 4

It may depend on what you are using to implement the regular expression. For example I found out the other day that Notepad++ only supports a few basic operators. Things like the pipe are not part of the core regex standard.

I'd suggest something like this:

([JjYy]{2}([JjYy]{2})?)?[0]{3,10}

If you're using a programming language, you'll need to use a string length function to validate the length.

EDIT: actually, you should be able to validate the length by separating the different situations:

([0]{3,10})|([JjYy]{2}[0]{3,8})|([JjYy]{4}[0]{3,6})

Answer 5

I'm afraid the RegEx would be lengthy and complicated. You should validate the first part via PHP code instead.