Regex to match exactly 5 numbers and one optional space

Question

I recently needed to create a regular expression to check input in JavaScript. The input could be 5 or 6 characters long and had to contain exactly 5 numbers and one optional space, which could be anywhere in the string. I am not regex-savvy at all and even though I tried looking for a better way, I ended up with this:

(^\d{5}$)|(^ \d{5}$)|(^\d{5} $)|(^\d{1} \d{4}$)|(^\d{2} \d{3}$)|(^\d{3} \d{2}$)|(^\d{4} \d{1}$)  

This does what I need, so the allowed inputs are (if 0 is any number)

'00000'  
' 00000'  
'0 0000'  
'00 000'  
'000 00'  
'0000 0'  
'00000 '

I doubt that this is the only way to achieve such matching with regex, but I haven't found a way to do it in a cleaner way. So my question is, how can this be written better?

Thank you.

Edit:
So, it is possible! Tom Lord's answer does what I needed with regular expressions, so I marked it as a correct answer to my question.

However, soon after I posted this question, I realized that I wasn't thinking right, since every other input in the project was easily 'validatable' with regex, I was immediately assuming I could validate this one with it as well.

Turns out I could just do this:

const validate = function(value) {
    const v = value.replace(/\s/g, '')
    const regex = new RegExp('^\\d{5}$');
    return regex.test(v);
}  

Thank you all for the cool answers and ideas! :)

Edit2: I forgot to mention a possibly quite important detail, which is that the input is limited, so the user can only enter up to 6 characters. My apologies.

Answer 1

Note: Using a regular expression to solve this problem might not be the best answer. As answered below, it may be easier to just count the digits and spaces with a simple function!

However, since the question was asking for a regex answer, and in some scenarios you may be forced to solve this with a regex (e.g. if you're tied down to a certain library's implementation), the following answer may be helpful:

This regex matches lines containing exactly 5 digits:

^(?=(\D*\d){5}\D*$)

This regex matches lines containing one optional space:

^(?=[^ ]* ?[^ ]*$)

If we put them together, and also ensure that the string contains only digits and spaces ([\d ]*$), we get:

^(?=(\D*\d){5}\D*$)(?=[^ ]* ?[^ ]*$)[\d ]*$

You could also use [\d ]{5,6} instead of [\d ]* on the end of that pattern, to the same effect.

Demo

Explanation:

This regular expression is using lookaheads. These are zero-width pattern matchers, which means both parts of the pattern are "anchored" to the start of the string.

• \d means "any digit", and \D means "any non-digit".

• means "space", and [^ ] means "any non-space".

• The \D*\d is being repeated 5 times, to ensure exactly 5 digits are in the string.

Here is a visualisation of the regex in action:

Note that if you actually wanted the "optional space" to include things like tabs, then you could instead use \s and \S.

---

Update: Since this question appears to have gotten quite a bit of traction, I wanted to clarify something about this answer.

There are several "simpler" variant solutions to my answer above, such as:

// Only look for digits and spaces, not "non-digits" and "non-spaces":
^(?=( ?\d){5} *$)(?=\d* ?\d*$)

// Like above, but also simplifying the second lookahead:
^(?=( ?\d){5} *$)\d* ?\d*

// Or even splitting it into two, simpler, problems with an "or" operator: 
^(?:\d{5}|(?=\d* \d*$).{6})$

Demos of each line above: 1 2 3

Or even, if we can assume that the string is no more than 6 characters then even just this is sufficient:

^(?:\d{5}|\d* \d*)$

So with that in mind, why might you want to use the original solution, for similar problems? Because it's generic. Look again at my original answer, re-written with free-spacing:

^
(?=(\D*\d){5}\D*$) # Must contain exactly 5 digits
(?=[^ ]* ?[^ ]*$)  # Must contain 0 or 1 spaces
[\d ]*$            # Must contain ONLY digits and spaces

This pattern of using successive look-aheads can be used in various scenarios, to write patterns that are highly structured and (perhaps surprisingly) easy to extend.

For example, suppose the rules changed and you now wanted to match 2-3 spaces, 1 . and any number of hyphens. It's actually very easy to update the regex:

^
(?=(\D*\d){5}\D*$)       # Must contain exactly 5 digits
(?=([^ ]* ){2,3}[^ ]*$)  # Must contain 2 or 3 spaces
(?=[^.]*\.[^.]*$)        # Must contain 1 period
[\d .-]*$   # Must contain ONLY digits, spaces, periods and hyphens

...So in summary, there are "simpler" regex solutions, and quite possibly a better non-regex solution to OP's specific problem. But what I have provided is a generic, extensible design pattern for matching patterns of this nature.

Answer 2

I suggest to first check for exactly five numbers ^\d{5}$ OR look ahead for a single space between numbers ^(?=\d* \d*$) among six characters .{6}$.

Combining those partial expressions yields ^\d{5}$|^(?=\d* \d*$).{6}$:

let regex = /^\d{5}$|^(?=\d* \d*$).{6}$/;

console.log(regex.test('00000'));   // true
console.log(regex.test(' 00000'));  // true
console.log(regex.test('00000 '));  // true
console.log(regex.test('00 000'));  // true
console.log(regex.test('  00000')); // false
console.log(regex.test('00000  ')); // false
console.log(regex.test('00  000')); // false
console.log(regex.test('00 0 00')); // false
console.log(regex.test('000 000')); // false
console.log(regex.test('0000'));    // false
console.log(regex.test('000000'));  // false
console.log(regex.test('000 0'));   // false
console.log(regex.test('000 0x'));  // false
console.log(regex.test('0000x0'));  // false
console.log(regex.test('x00000'));  // false

Alternatively match the partial expressions separately via e.g.:

/^\d{5}$/.test(input) || input.length == 6 && /^\d* \d*$/.test(input)

Answer 3

This seems more intuitive to me and is O(n)

function isInputValid(input) {
    const length = input.length;
    if (length != 5 && length != 6) {
        return false;
    }

    let spaceSeen = false;
    let digitsSeen = 0;
    for (let character of input) {
        if (character === ' ') {
            if (spaceSeen) {
                return false;
            }
            spaceSeen = true;
        }
        else if (/^\d$/.test(character)) {
            digitsSeen++;
        }
        else {
            return false;
        }
    }

    return digitsSeen == 5;
}

Answer 4

You can split it in half:

var input = '0000 ';

if(/^[^ ]* [^ ]*$/.test(input) && /^\d{5,6}$/.test(input.replace(/ /, '')))
  console.log('Match');

Answer 5

Here's a simple regex to do the job:

^(?=[\d ]{5,6}$)\d*\s?\d*$

Explanation:

^ asserts position at start of the string

Positive Lookahead (?=[\d ]{5,6}$)

Assert that the Regex below matches

Match a single character present in the list below [\d ]{5,6}

{5,6} Quantifier — Matches between 5 and 6 times, as many times as possible, giving back as needed (greedy)

\d matches a digit (equal to [0-9]) matches the character literally (case sensitive)

$ asserts position at the end of the string \d* matches a digit (equal to [0-9])

• Quantifier — Matches between zero and unlimited times, as many times as possible, giving back as needed (greedy)

\s matches any whitespace character (equal to [\r\n\t\f\v ])

\d* matches a digit (equal to [0-9])

• Quantifier — Matches between zero and unlimited times, as many times as possible, giving back as needed (greedy)

$ asserts position at the end of the string

Answer 6

string="12345 ";
if(string.length<=6 && string.replace(/\s/g, '').length<=5 && parseInt(string,10)){
  alert("valid");
}

You could simply check the length and if its a valid number...

Answer 7

This is how I would do it without regex:

string => [...string].reduce(
    ([spaces,digits], char) =>
        [spaces += char == ' ', digits += /\d/.test(char)],
    [0,0]
).join(",") == "1,5";