Does the quantifier {0} make sense in some scenarios?

Example:

/(?:Foo){0}bar/

I saw something like this in another answer. At first I thought "what should that be", but then, "OK could make sense, kind of a negative look behind", so that Foo is not allowed before bar, but this is not working.

You can see this here on Regexr: It matches only bar but it matches also the bar in Foobar.

When 开发者_JAVA百科I add an anchor for the start of the row:

/^(?:Foo){0}bar/

it behaves like I expect. It matches only the bar and not the bar in Foobar.

But that's exactly the same behaviour as if I used only /bar/ or /^bar/.

Is the quantifier {0} only a useless side effect, or is there really a useful behaviour for that?

There are good uses of {0}. It allows you to define groups that you don't intend to capture at the moment. This can be useful in some cases:

• The best one - use of the group in recursive regular expressions (or other weird constructs). Perl, for example, has (?(DEFINE) ) for the same use.
  A quick example - in PHP, this will match barFoo (working example):

  preg_match("/(?:(Foo)){0}bar(?1)/", "barFoo", $matches);
  

• Adding a failed captured group (named or numbered) to the result matches.

• Keeping the indices of all groups intact in case the pattern was refactored.

Less good uses, as Peter suggested are useful in:

• Generated patterns.
• Readability - Patterns with certain duplication, where {0} and {1} may lead thinking in the right direction. (OK, not the best point)

These are all rare cases, and in most patterns it is a mistake.

An explicit repetition count of zero can be useful in automatically generated regular expressions. You avoid coding a special case for zero repetitions this way.

In traditional regular expressions, /x{0}/ (language = { xⁿ : x = 0}) would mean "match exactly 0 of x", which is the same thing as // (language = { Λ }). Since the two are equivalent, you should be able to remove any /x{0}/ you find lying around.

But PCREs and other extensions to regular expressions can get quite byzantine. I would not be surprised if /x{0}/ did something in Perl. I would be disgusted, but not surprised.

I think it's probably some artifact of a program that automatically generates regular expressions but doesn't simplify them. Which is a shame, since it's so easy to write programs that simplify regular expressions.

I can't think of a single good reason to use x{0}. But I can think of several why it should be avoided:

• It's useless since it always matches.
• It slows the regex engine down (unless the regex is precompiled).
• It's probably a sign of misunderstanding by the regex author.

I'm willing to bet that someone who writes (?:foo){0} is trying to say "make sure that foo doesn't match here", which of course fails because the empty string can always be matched, whether foo is there or not. That's what negative lookaround assertions are for. (?<!foo)bar etc.