• PCRE regex
  • Conditional subpatterns

  • Conditional subpatterns
  • Conditional subpatterns

    Conditional subpatterns

    It is possible to cause the matching process to
    obey a subpattern conditionally or to choose between two
    alternative subpatterns, depending on the result of an assertion,
    or whether a previous capturing subpattern matched or not. The two
    possible forms of conditional subpattern are


    If the condition is satisfied, the yes-pattern is
    used; otherwise the no-pattern (if present) is used. If there are
    more than two alternatives in the subpattern, a compile-time error

    There are two kinds of condition. If the text
    between the parentheses consists of a sequence of digits, then the
    condition is satisfied if the capturing subpattern of that number
    has previously matched. Consider the following pattern, which
    contains non-significant white space to make it more readable
    (assume the PCRE_EXTENDED option) and to divide it into three parts
    for ease of discussion:

    ( \( )?    [^()]+    (?(1) \) )

    The first part matches an optional opening
    parenthesis, and if that character is present, sets it as the first
    captured substring. The second part matches one or more characters
    that are not parentheses. The third part is a conditional
    subpattern that tests whether the first set of parentheses matched
    or not. If they did, that is, if subject started with an opening
    parenthesis, the condition is TRUE,
    and so the yes-pattern is executed and a closing parenthesis is
    required. Otherwise, since no-pattern is not present, the
    subpattern matches nothing. In other words, this pattern matches a
    sequence of non-parentheses, optionally enclosed in

    If the condition is the string (R), it is
    satisfied if a recursive call to the pattern or subpattern has been
    made. At “top level”, the condition is false.

    If the condition is not a sequence of digits or
    (R), it must be an assertion. This may be a positive or negative
    lookahead or lookbehind assertion. Consider this pattern, again
    containing non-significant white space, and with the two
    alternatives on the second line:

    \d{2}-[a-z]{3}-\d{2}  |  \d{2}-\d{2}-\d{2} )

    The condition is a positive lookahead assertion
    that matches an optional sequence of non-letters followed by a
    letter. In other words, it tests for the presence of at least one
    letter in the subject. If a letter is found, the subject is matched
    against the first alternative; otherwise it is matched against the
    second. This pattern matches strings in one of the two forms
    dd-aaa-dd or dd-dd-dd, where aaa are letters and dd are digits.