Regular expression syntax

Regular expression syntax has several basic rules and methods.

The pattern within the brackets of a regular expression defines a character set that is used to match a single character. For example, the regular expression "[ A-Za-z] " specifies to match any single uppercase or lowercase letter.

In the character set, a hyphen indicates a range of characters, for example [A-Z] will match any one capital letter.

In a character set a ^ character negates the following characters. For example [^A-Z] matches any single character that is not a capital letter.

The regular expression " B[IAU]G " matches the strings "BIG", "BAG", and "BUG", but does not match the string "BOG".

If you specified the regular expression as "B[IA][GN]", the concatenation of character sets creates a regular expression that matches the corresponding concatenation of characters in the search string. This regular expression matches  "B", followed by an "I" or "A", followed by a "G" or "N". The regular expression matches "BIG", "BAG", "BIN", and "BAN".

The regular expression [A-Z][a-z]* matches any sequence of letters that starts with an uppercase letter and is followed by zero or more lowercase letters. The special character * after the closing square bracket specifies to match zero or more occurrences of the character set.

A + after the closing square bracket specifies to find one or more occurrences of the character set. You interpret the regular expression {{"A-Z+" }}as matching one or more uppercase letters enclosed by spaces. Therefore, this regular expression matches " BIG " and also matches " LARGE ", " HUGE ", " ENORMOUS ", and any other string of uppercase letters surrounded by spaces.

Changes in ColdFusion (2018 release) Update 5

In Update 5 of the 2018 release of ColdFusion, the application flag useJavaAsRegex is introduced. If you enable this flag at the application level, you can override the default Regex engine and you can use the Java Regex engine.

You can also enable the option at the server level. Enable the option Use Java As Regex Engine, located in Server Settings > Settings of the ColdFusion Administrator.

For example, using the default Perl-regex engine, you can write the following snippet:

After you enable the flag useJavaAsRegex, you can rewrite the snippet above as follows:

Feature comparison of Perl and Java Regex engines

For more information on Regex patterns in Java, see the official Oracle docs on Regex.

Considerations when using special characters

Since a regular expression followed by an * can match zero instances of the regular expression, it can also match the empty string. For example,

results in the following output:

The regular expression T* can match empty strings. It first matches the empty string before "H" in "Hello". The "ALL" argument tells REReplace to replace all instances of an expression. The empty string before "e" is matched, and so on, until the empty string before "o" is matched.

This result might be unexpected. The workarounds for these types of problems are specific to each case. In some cases you can use [T]+, which requires at least one "T", instead of [T]*. Alternatively, you can specify an additional pattern after [T]*. 
In the following examples the regular expression has a "W" at the end:

This expression results in the following more predictable output:

Finding repeating characters

In some cases, you might want to find
a repeating pattern of characters in a search string. For example,
the regular expression "a{2,4}" specifies to match two to four occurrences
of "a". Therefore, it would match: "aa", "aaa", "aaaa", but not
"a" or "aaaaa". In the following example, the REFind function returns an index of 6:

The regular expression "[0-9]{3,}" specifies to match any integer

number containing three or more digits: "123", "45678", and so on.
However, this regular expression does not match a one-digit or two-digit
number. 

You use the following syntax to find repeating characters:

Case sensitivity in regular expressions

ColdFusion supplies case-sensitive and case-insensitive functions for working with regular expressions. REFind and REReplace perform case-sensitive matching and REFindNoCase and REReplaceNoCase perform case-insensitive matching. 
You can build a regular expression that models case-insensitive behavior, even when used with a case-sensitive function. To make a regular expression case insensitive, substitute individual characters with character sets. For example, the regular expression [Jj][Aa][Vv][Aa], when used with the case-sensitive functions REFind or REReplace, matches all of the following string patterns:

• JAVA
• java
• Java
• jAva
• All other combinations of case

Using subexpressions

Parentheses group parts of regular expressions into subexpressions that you can treat as a single unit. For example, the regular expression "ha" specifies to match a single occurrence of the string. The regular expression "(ha)+" matches one or more instances of "ha". 
In the following example, you use the regular expression "B(ha)+" to match the letter "B" followed by one or more occurrences of the string "ha":

You can use the special character | in a subexpression to create a logical "OR". You can use the following regular expression to search for the word "jelly" or "jellies":

Using special characters

Regular expressions define the following list of special characters:

In some cases, you use a special character as a literal character. For example, if you want to search for the plus sign in a string, you have to escape the plus sign by preceding it with a backslash:

The following table describes the special characters for regular expressions:

You must be aware of the following considerations when using special characters in character sets, such as a-z:

• To include a hyphen (-) in the brackets of a character set as a literal character, you cannot escape it as you can other special characters because ColdFusion always interprets a hyphen as a range indicator. Therefore, if you use a literal hyphen in a character set, make it the last character in the set.
• To include a closing square bracket (]) in the character set, escape it with a backslash, as in [1-3]A-z]. You do not have to escape the ] character outside the character set designator.

Using escape sequences

Escape sequences are special characters in regular expressions preceded by a backslash (). You typically use escape sequences to represent special characters within a regular expression. For example, the escape sequence \t represents a tab character within the regular expression, and the \d escape sequence specifies any digit, as [0-9] does. ColdFusion escape sequences are case sensitive.
The following table lists the escape sequences that ColdFusion supports:

Using character classes

In character sets within regular expressions, you can include a character class. You enclose the character class inside brackets, as the following example shows:

This code replaces all the spaces with *, producing this string:

You can combine character classes with other expressions within a character set. For example, the regular expression [space:123] searches for a space, 1, 2, or 3. The following example also uses a character class in a regular expression:

The following table shows the character classes that ColdFusion supports. Regular expressions using these classes match any Unicode character in the class, not just ASCII or ISO-8859 characters.