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
(?(condition)yes-pattern) (?(condition)yes-pattern|no-pattern)
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 occurs.
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 parentheses.
  
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:
(?(?=[^a-z]*[a-z])
\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.