What regular expression can never match?

Question

Several times recently I've wanted to create a regular expression that will never match any input (even an empty string). Some of the apparently most obvious ways are either very crude, turn out to have undesirable behaviour... or just plain don't work!

My provisional solution, which works fine for my particular case is simply a pattern of '\x00NEVERMATCHES\x00' (Python syntax for a string bracketed by two NUL bytes). It's self-documenting and, given the binary content, can never match my text-only input. What about the case where the input has no such restrictions?

A reading of the Javascript and Python regular expression docs didn't bring anything simple to mind. What would be your approach to this?

Solutions in any fairly generic regex syntax would be fine. My particular uses would be in Javascript and Python, but their regex syntaxes are pretty typical so I won't limit the answers unnecessarily at this point.

Answer 1

Maybe this?

/$.+^/

Answer 2

What about instead of regex, just use an always false if statement? In javascript:

var willAlwaysFalse=false;
if(willAlwaysFalse)
{
}
else
{
}

Answer 3

Leverage negative lookahead:

>>> import re
>>> x=r'(?!x)x'
>>> r=re.compile(x)
>>> r.match('')
>>> r.match('x')
>>> r.match('y')

this RE is a contradiction in terms and therefore will never match anything.

Answer 4

Python won't accept it, but Perl will:

perl -ne 'print if /(w\1w)/'

This regex should (theoretically) try to match an infinite (even) number of ws, because the first group (the ()s) recurses into itself. Perl doesn't seem to be issuing any warnings, even under use strict; use warnings;, so I assume it's at least valid, and my (minimal) testing fails to match anything, so I submit it for your critique.

Answer 5

$.

.^

$.^

(?!)

Answer 6

The fastest will be:

r = re.compile(r'a^')
r.match('whatever')

'a' can be any non-special character ('x','y'). Knio's implementation might be a bit more pure but this one will be faster for all strings not starting with whatever character you choose instead of 'a' because it will not match after the first character rather than after the second in those cases.

Answer 7

Perl 5.10 supports special control words called "verbs", which is enclosed in (*...) sequence. (Compare with (?...) special sequence.) Among them, it includes (*FAIL) verb which returns from the regular expression immediately.

Note that verbs are also implemented in PCRE shortly after, so you can use them in PHP or other languages using PCRE library too. (You cannot in Python or Ruby, however. They use their own engine.)

Answer 8

I believe that

\Z RE FAILS! \A

covers even the cases where the regular expression includes flags like MULTILINE, DOTALL etc.

>>> import re
>>> x=re.compile(r"\Z RE FAILS! \A")
>>> x.match('')
>>> x.match(' RE FAILS! ')
>>>

I believe (but I haven't benchmarked it) that whatever the length (> 0) of the string between \Z and \A, the time-to-failure should be constant.

Answer 9

[^\d\D] or (?=a)b or a$a or a^a

Answer 10

One that was missed:

^\b$

It can't match because the empty string doesn't contain a word boundary. Tested in Python 2.5.