Regular expressions in Mathematica

Outline:

Overview
Mathematica’s regular expression flavor
Matching and replacing
Replacing
Case-sensitivity
More about regular expressions

Overview

This page is written for the benefit of someone familiar with regular expressions but not with the use of regular expressions in Mathematical. Comparisons will be made with Perl for those familiar with the language, though no knowledge of Perl is required.

Mathematica’s regular expression flavor

Mathematica uses essentially the same regular expression flavor as Perl 5. Specifically, Mathematica is compatible with PCRE. Note that metacharacters require two backslashes. For example, the\d shortcut for matching any digit must be written as \\d.

Matching

The Mathematica function StringFreeQ is analogous to the m// operator in Perl. However, The logic of StringFreeQ is inverted compared to m// because it returns whether a string is “free” of a pattern, i.e. it returns True if the string does not contain the pattern and False if it does.

The first argument to StringFreeQ is the string to search. The second argument can be a simple string or a regular expression.

Examples:

StringFreeQ["Hello world", "ello"]

returns False because the string “Hello world” does contain “ello”.

StringFreeQ["Hello world", "el+o"]

returns True because “Hello world” does not contain the literal string “el+o”. However

StringFreeQ["Hello world", RegularExpression["el+o"]]

returns False because “Hello world” does match the regular expression el+o.

If you want retrieve the text matched rather than simply asking whether there was a match, use StringCases. This function returns a list containing all matches. Of cours the list will be empty if there were no matches.

Replacing

The Mathematica function StringReplace is analogous to Perl’s s/// operator. The first argument is the string to operate on. The second is a regular expression followed by -> and a replacement string.

Example:

StringReplace["Hello world", RegularExpression["world"] -> "planet"]

returns “Hello planet”. Note that StringReplace does not modify its arguments. If the replacement pattern needs to reference captured subexpressions, these can be accessed by $1, $2, etc. just as in Perl.

Example:

StringReplace["Hello world", RegularExpression["(world)"] -> "planet $1"]

returns “Hello planet world”.

Note that StringReplace replaces all matches in a string by default, and so it is more precisely analogous to s//g than s//. To limit the number of matches, add a third argument specifying the maximum number of replacements. For example, adding 1 as the last argument causes only the first instance to be replaced.

Example:

StringReplace["Hello world", RegularExpression["o"] -> "x", 1]

returns “Hellx world”. Without the final argument it would have returned “Hellx wxrld.”

Case-sensitivity

The m// and s/// operators in Perl are case-sensitive by default. Perl has two ways of making these operators case-insensitive. One is by appending an ‘i‘ following the operator. The other is to add (?i) to the beginning of the regular expression.

Mathematica is also case-sensitive by default, and it also has two ways of changing the case-sensitivity. One is to use the attribute IgnoreCase -> True. The other is to add (?i) to the regular expression as in Perl.

More about regular expressions

Notes on using regular expression in other languages: C++, Python, R, PowerShell

Tips for getting started with regular expressions

For daily tips on regular expressions, follow @RegexTip on Twitter.

Regex tip icon