Most implementations have specific shorthands for the alert, backspace, escape character, form feed, newline, carriage return, horizontal tab, and vertical tab characters. For example, is often a shorthand for the newline character, which is usually LF (012 octal) but can sometimes be CR (15 octal) depending on the operating system. Confusingly, many implementations use  to mean both backspace and word boundary (between a “word” character and a non-word character). For these implementations,  means backspace in a character class (a set of possible characters to match in the string) and word boundary elsewhere.

Represents a character corresponding to a two- or three- octal digit number. For example, 1512 matches an ASCII CR/LF sequence.

Represents a character corresponding to a hexadecimal number. Four-digit and larger hex numbers can represent the range of Unicode characters. For example, x0Dx0A matches an ASCII CR/LF sequence.

Corresponds to ASCII control characters encoded with values less than 32. To be safe, always use an uppercase char—some implementations do not handle lowercase representations. For example, cH matches Control-H, an ASCII backspace character.

Character classes, [...], and negated character classes, [^...], allow you to list the characters that you do or do not want to match. A character class always matches one character. The - (dash) indicates a range of characters. To include the dash in the list of characters, list it first or escape it. For example, [a-z] matches any lowercase ASCII letter.

Usually matches any character except a newline. The match mode can often be changed so that dot also matches newlines.

Commonly provided shorthands for word character, digit, and space character classes. A word character is often all ASCII alphanumeric characters plus the underscore. However, the list of alphanumerics can include additional locale or Unicode alphanumerics, depending on the implementation. For example, d matches a single digit character and is usually equivalent to [0-9].

POSIX defines several character classes that can be used only within regular expression character classes (see Table 1-1). For example, [:lower:], when written as [[:lower:]], is equivalent to [a-z] in the ASCII locale.

The Unicode standard defines classes of characters that have a particular property, belong to a script, or exist within a block. Properties are characteristics such as being a letter or a number (see Table 1-2). Scripts are systems of writing, such as Hebrew, Latin, or Han. Blocks are ranges of characters on the Unicode character map. Some implementations require that Unicode properties be prefixed with Is or In. For example, p{Ll} matches lowercase letters in any Unicode supported language, such as a or α.

Matches a Unicode base character followed by any number of Unicode combining characters. This is a shorthand for P{M}p{M}. For example, X matches è as well as the two characters e‘.

Matches at the beginning of the text being searched. In multiline mode, ^ matches after any newline. Some implementations support A, which only matches at the beginning of the text.

$ matches at the end of a string. Some implementations also allow $ to match before a string-ending newline. If modified by multiline mode, $ matches before any newline as well. When supported,  matches the end of string or before a string-ending newline, regardless of match mode. Some implementations also provide z, which only matches the end of the string, regardless of newlines.

In iterative matching, G matches the position where the previous match ended. Often, this spot is reset to the beginning of a string on a failed match.

Word boundary metacharacters match a location where a word character is next to a non-word character.  often specifies a word boundary location, and B often specifies a not-word-boundary location. Some implementations provide separate metasequences for start- and end-of-word boundaries, often < and >.

Lookaround constructs match a location in the text where the subpattern would match (lookahead), would not match (negative lookahead), would have finished matching (lookbehind), or would not have finished matching (negative lookbehind). For example, foo(?=bar) matches foo in foobar but not food. Implementations often limit lookbehind constructs to subpatterns with a predetermined length.

Changes the behavior of ^ and $ to match next to newlines within the input string.

Changes the behavior of . (dot) to match all characters, including newlines, within the input string.

Treat as identical letters that differ only in case.

Allows for whitespace and comments within a regular expression. The whitespace and comments (starting with # and extending to the end of the line) are ignored by the regular expression engine.

Usually, mode modifiers may be set within a regular expression with (?mod) to turn modes on for the rest of the current subexpression; (?-mod) to turn modes off for the rest of the current subexpression; and (?mod:...) to turn modes on or off between the colon and the closing parentheses. For example, "use (?i:perl)" matches “use perl”, “use Perl”, “use PeRl”, etc.

In free-spacing mode, # indicates that the rest of the line is a comment. When supported, the comment span (?#...) can be embedded anywhere in a regular expression, regardless of mode. For example, .{0,80}(?#Field limit is 80 chars) allows you to make notes about why you wrote .{0,80}.

Escapes metacharacters between Q and E. For example, Q(.*)E is the same as (.*).

Parentheses perform two functions: grouping and capturing. Text matched by the subpattern within parentheses is captured for later use. Capturing parentheses are numbered by counting their opening parentheses from the left. If backreferences are available, the submatch can be referred to later in the same match with 1, 2, etc. The captured text is made available after a match by implementation-specific methods. For example, (w+)s+1 matches duplicate words, such as the the.

Groups a subexpression, possibly for alternation or quantifiers, but does not capture the submatch. This is useful for efficiency and reusability. For example, (?:foobar) matches foobar, but does not save the match to a capture group.

Performs capturing and grouping, with captured text later referenced by name. For example, Subject:(?<subject>.*) captures the text following Subject: to a capture group that can be referenced by the name subject.

Text matched within the group is never backtracked into, even if this leads to a match failure. For example, (?>[ab]*)ww matches aabbcc but not aabbaa.

Allows several subexpressions to be tested. Alternation’s low precedence sometimes causes subexpressions to be longer than intended, so use parentheses to specifically group what you want alternated. For example, (foo|bar) matches either of the words foo or bar.

The if is implementation dependent, but generally is a reference to a captured subexpression or a lookaround. The then and else parts are both regular expression patterns. If the if part is true, the then is applied. Otherwise, else is applied. For example, (<)?foo(?(1)>|bar) matches <foo> and foobar.

The greedy quantifiers determine how many times a construct may be applied. They attempt to match as many times as possible, but will backtrack and give up matches if necessary for the success of the overall match. For example, (ab)+ matches all of ababababab.

Lazy quantifiers control how many times a construct may be applied. However, unlike greedy quantifiers, they attempt to match as few times as possible. For example, (an)+? matches only an of banana.

Possessive quantifiers are like greedy quantifiers, except that they “lock in” their match, disallowing later backtracking to break up the sub-match. For example, (ab)++ab will not match ababababab.