Regular Expression Syntax

Suppose you want to search for a string with the word cat in it. In that case, your regular expression would simply be cat. If your search is case-insensitive, the words catalog, Catherine, or sophisticated would also match:

• Regular expression: cat
• Matches: catalog, Catherine, sophisticated

To match a three-letter word starting with the t letter and ending with the n letter as a regular expression, you can use a wildcard notation – the period character (.). The regular expression would then be t.n and would match tan, ten, tin, and ton; it would also match t#n, tpn, and even t n, as well as many other nonsensical words. This is because the period character matches everything, including the space, the tab character, and even line breaks:

• Regular expression: t.n
• Matches: tan, ten, tin, ton, t#n, tpn, t n

To solve the problem of the period’s indiscriminate matches, you can specify characters you consider meaningful with the bracket ([ ]) expression, so that only those characters would match the regular expression. Thus, t[aeio]n would just match tan, ten, tin, and ton. toon would not match because you can only match a single character within the bracket notation:

• Regular expression: t[aeio]n
• Matches: tan, ten, tin, ton

If you want to match toon in addition to all the words matched in the previous section, you can use the | notation, which is basically an OR operator. To match toon, use the regular expression t(a|e|i|o|oo)n. You cannot use the bracket notation here because it will only match a single character. Instead, use parentheses (( )):

• Regular expression: t(a|e|i|o|oo)n
• tan, ten, tin, ton, toon

As you can see, parentheses may be used for grouping contiguous sets of character patterns together with an optional | operator to provide alternative selections during matching. That is, any of the alternative patterns within the group may produce a match (with left to right precedence):

• Regular expression: Good (morning|afternoon|evening)!
• Matches: Good morning!, Good afternoon!, Good evening!

You may also want append quantifier notations to specify how often a particular character or group of characters should repeat. For example, you can use the * notation to specify that the previous character should match zero or more times:

• Regular expression:: Surprise!*
• Matches: Surprise!, Surprise!!, Surprise!!!

If the * notation is combined with the wildcard (period) character, it will match all (zero or more) characters, including spaces, tabs, and line breaks between two separate notations:

• Regular expression: Hello.*There!
• Matches: HelloThere!, Hello There!, Hello everyone over There!

The following quantifier notations may be used to determine how many times a given notation to the immediate left of the quantifier notation should repeat itself:

You may also want to match a particular format or template of text, rather than a literal pattern of static characters. For example, you want to match a generic social security number pattern. The format for US social security numbers is 999-99-9999. The regular expression you would use to match this is as follows:

• Regular expression: [0-9]{3}\-[0-9]{2}\-[0-9]{4}
• Matches: All social security numbers of the form 123-12-1234

In regular expressions, the hyphen (-) notation has special meaning; it indicates a (sequential) range of possible characters such as A-Z, a-z, or 0-9. Thus, the notation [0-9]{3} in the first element of the pattern matches any string of exactly 3 digits, each of which may range from 0-9. This is followed by an escaped hyphen character. You must escape the - character with a forward slash (\) when matching literal hyphens in a pattern because of its special meaning within a regular expression.

If, in your template pattern, you wish to make the hyphen optional, say, you consider both 999-99-9999 and 999999999 acceptable formats, you can use the ? quantifier notation as shown:

• Regular expression: [0-9]{3}\-?[0-9]{2}\-?[0-9]{4}
• Matches: All social security numbers of the forms 123-12-1234 and 1231212345

Let us take a look at another example. One format for US car plate numbers consists of four numeric characters followed by two letters. Thus, a regular expression might first include a [0-9]{4} numeric part, followed by a [A-Z]{2} textual part:

• Regular expression: [0-9]{4}[A-Z]{2}
• Matches: US car plate numbers of the 8836KV format

The ^ notation is also called the NOT notation. If used in brackets, ^ indicates the character(s) you do not want to match. For example, the expression below matches all words except those starting with the letter x:

• Regular expression: \b[^xy][a-z]+\b
• Matches: All (lowercase) words except those that start with the x or y letters

In the above example, the + quantifier is used to specify one or more characters in range of a-z, and the \b notation is used to match at word boundaries.

To make life easier, some shorthand notations for commonly used regular expressions also exist, as shown below:

To illustrate, we can use \d for all instances of [0-9] we used before, as was the case with our social security number expressions. The revised regular expression is:

• Regular expression: \d{3}\-\d{2}\-\d{4}Matches: All social security numbers of the form 123-12-1234

Or, suppose you want to match an IP address. It consists of four 1-byte segments (octets), each segment has a value between 0 and 255 and is separated from the others by a period. Thus, in each individual segment of the IP address, you have at least one and at most three digits. The following regular expression might be used to match just such a construct:

• Regular expression: \d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}
• Matches: IP addresses that consist of four 3-digit segments, each with values between 0 and 255

You need to escape the period character because you literally want it to be there; you do not want it read in terms of its special meaning in regular expression syntax, as explained earlier. Other special characters that need to be escaped when used in a literal match are discussed in the Additional Considerations section below.

Perhaps you are trying to match a particular type of date string. A typical date format might be: June 26, 1951. One example of a regular expression to match strings of this type would be:

• Regular expression: [A-Za-z]+\s+[0-9]{1,2},\s*[0-9]{4}
• Matches: All dates with the format of Month DD, YYYY

Broken down, the first element of the expression ([A-Za-z]+) matches the month (rather, a word consisting of at least 1 alphabetic character), followed by a mandatory space (\s+), followed by the day of the month up to 2 digits ([0-9]{1,2}), followed by a mandatory comma, followed by an optional space (\s*) followed by a four-digit year field ([0-9]{4}). This pattern may be adequate, but you might also choose to enclose the full set of month names within a parenthetical grouping, separate by the | notation, such as (January|February|March ... ) instead of the weaker [A-Za-z]+ notation.

The following table defines additional notations that may be useful in your regular expression pattern matches:

You might want to construct patterns where multiple search subpatterns may appear anywhere on the page, in any order. Here are some potential solutions (where ALPHA and BETA are your keywords or sub-patterns):

You might want to construct patterns which make use of look-ahead and look-behind assertions. Here are some potential solutions (where ALPHA and BETA are your keywords or sub-patterns):

To make your match criteria wholly or partially case insensitive, you may embed the (?i) and (?i:pattern) notations within your regular expressions, respectively. Here are some potential solutions (where ALPHA and BETA are your keywords or sub-patterns):