Regular expression syntax

• About regular expressions
• Wildcards
• Anchors
• Marked subexpressions
• Non-marking groupings
• Repeats
• Back references
• Alternation
• Character sets
• Escapes
• Perl-specific extensions
• Operator precedence

.[]{}()\*+?|^$

^(a{2,3}).*\1$

• Single characters. For example, [abc] matches any of the characters a, b, or c.
• Character ranges. For example, [a-c] matches any single character in the range a through c. By default, for Perl regular expressions, a character x is within the range y to z, if the code point of the character lies within the code points of the endpoints of the range.
• Negation. If the bracket expression begins with the ^ character, it matches the complement of the characters that it contains. For example, [^a-c] matches any character that is not in the range a through c.
• Character classes. An expression of the form [[:name:]] matches the named character class name. For example, [[:lower:]] matches any lowercase character. The supported character classes are as follows:

  Character Class	Description	Character Class	Description
  alnum	Any alphanumeric character.	punct	Any punctuation character.
  alpha	Any alphabetic character.	s	Any whitespace character.
  blank	Any whitespace character that is not a line separator.	space	Any whitespace character.
  cntrl	Any control character.	unicode	Any extended character whose code point is above 255 in value.
  d	Any decimal digit.	u	Any uppercase character.
  digit	Any decimal digit.	upper	Any uppercase character.
  graph	Any graphical character.	w	Any word character (alphanumeric characters plus the underscore).
  l	Any lowercase character.	word	Any word character (alphanumeric characters plus the underscore).
  lower	Any lowercase character.	xdigit	Any hexadecimal digit character.
  print	Any printable character.	-	-

• Escaped characters. All the escape sequences that match a single character or character class are permitted within a character class definition. For example, [[]] matches both [ and ], whereas [\W\d] matches any character that is either a digit or not a word character.
• Combinations. You can combine one or more of the above in a character set declaration. For example, [a-cmnx-y\d].

• Named subexpressions
  You can create a named subexpression as follows:
  (?<NAME>expression)
  You can then refer to the subexpression by the name NAME. Alternatively, you can delimit the name as follows:
  (?'NAME'expression)
  You can then refer to the subexpression in a backreference using either:
  \g{NAME}
  or
  \k<NAME>
• Comments
  (?# ...)
  Treats the enclosed text as a comment. Its contents are ignored.
• Modifiers
  (?imsx-imsx ...)
  Alters which Perl modifiers are in effect within the pattern. Changes take effect from the point that the block is first encountered and extend to any enclosing group. Letters before - enable the corresponding modifier, and letters after - disable it.
  (?imsx-imsx:pattern)
  Applies the specified modifiers to pattern only.
• Non-marking groups
  (?:pattern)
  Groups pattern lexically without creating an additional subexpression.
• Lookahead
    ```regex
  (?=pattern)
  ```

  Consumes zero characters, but only if `pattern` matches.

  ```regex
  (?!pattern)
  ```

  Consumes zero characters, but only if `pattern` does **not** match.

  You can typically use lookaheads to create the logical **AND** of two regular expressions.

  For example, to validate a password that must contain a lowercase letter, an uppercase letter, and a punctuation symbol, and must be at least six characters long:

  ```regex
  (?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}
  ```
• Lookbehind
    ```regex
  (?<=pattern)
  ```

  Consumes zero characters, but only if `pattern` can be matched against the characters preceding the current position (`pattern` must be of fixed length).

  ```regex
  (?<!pattern)
  ```

  Consumes zero characters, but only if `pattern` cannot be matched against the characters preceding the current position (`pattern` must be of fixed length).
• Independent subexpressions
    ```regex
  (?>pattern)
  ```

  Matches `pattern` independently of the surrounding pattern. The expression never backtracks into `pattern`.
• Conditional expressions
    ```regex
  (?(condition)yes-pattern|no-pattern)
  ```

  Tries to match `yes-pattern` if the condition is true; otherwise, matches `no-pattern`.

  ```regex
  (?(condition)yes-pattern)
  ```

  Tries to match `yes-pattern` if the condition is true; otherwise, matches the NULL string.

  A condition can be one of the following:

  - A forward lookahead assertion.
  - The index of a marked subexpression (the condition becomes true if the subexpression has been matched).

  The following table summarizes the possible predicates:      

  | Predicate | Description |
  |-----------|-------------|
  | `(?(?=assert)yes-pattern\|no-pattern)` | Executes `yes-pattern` if the forward lookahead assertion matches; otherwise executes `no-pattern`. |
  | `(?(?!assert)yes-pattern\|no-pattern)` | Executes `yes-pattern` if the forward lookahead assertion does **not** match; otherwise executes `no-pattern`. |
  | `(?(N)yes-pattern\|no-pattern)` | Executes `yes-pattern` if subexpression **N** has been matched; otherwise executes `no-pattern`. |
  | `(?(<name>)yes-pattern\|no-pattern)` | Executes `yes-pattern` if the named subexpression has been matched; otherwise executes `no-pattern`. |
  | `(?(\'name\')yes-pattern\|no-pattern)` | Executes `yes-pattern` if the named subexpression has been matched; otherwise executes `no-pattern`. |

1. Escaped characters \
2. Character set (bracket expression) []
3. Grouping ()
4. Single-character ERE duplication *, +, ?, {m,n}
5. Concatenation
6. Anchoring ^$

Related information