Character Classes and Anchors

Many learners meet a character class name such as digit and assume that writing the name by itself is enough to match a digit. The belief is understandable, because in everyday language a digit is a decimal digit. In a regular expression, however, the notation has its own rules, and the bare name does not carry the full meaning. This article starts by testing that belief, then builds the correct picture from the rules that the notation defines.

When you write a pattern, each piece of it normally matches exactly once. The default, when no suffix is added, is exactly once. This means a suffix is the only way to tell a matcher that a piece should occur a different number of times. Without a suffix, a piece such as the letter a is read as one a, and no more and no fewer.

A suffix attaches to the piece in front of it and states how many consecutive occurrences are allowed. Once you can read those suffixes fluently, you can describe patterns such as three of these, no more and no fewer, or at least one of these, directly in the pattern itself. You do not need to write out the repeated piece many times.

There are six notations in total. The first three use braces and take explicit numbers. The last three are symbols that stand for common counts. The table below gives each notation, its meaning in words, and its equivalent brace form where one is given.

Deciding whether a string matches a pattern comes down to counting. A string fails a pattern when any single piece has the wrong count. The matcher reads the string, consumes occurrences of the piece while the count allows, and fails when the string offers more occurrences than the notation permits or fewer than it requires.

The same logic explains the failures that the source annotates. The source gives the string AAABBBBBCCC as an example that does not match its pattern and annotates it as having too many Bs. Each annotation identifies a single letter whose count is off, so the annotation tells you which piece of the pattern has the wrong count, and that piece is the one to revisit.

A character class is an entry in a list of named sets of characters. The list covers things like alphanumeric characters, alphabetic characters, whitespace, punctuation, and hexadecimal digits. Each name describes a set, and the set is what the pattern matches. The name must be written in a particular way for the engine to recognize it as a class rather than as ordinary text.

The notation works in two layers. The inner layer is the class name, wrapped in the delimiters [: and :]. The outer layer is an ordinary bracket pair, [ ], which marks the whole construction as a character class inside the pattern. The class name [:digit:] matches a decimal digit, but it must be used within a bracket pair to form a working expression, giving [[:digit:]].

Writing [[:digit:]] every time is precise but verbose, so the notation provides shorthand forms for several common classes. Each shorthand is a backslash followed by a letter. The shorthand \d stands for [[:digit:]], \s stands for [[:space:]], and \w stands for [_[:alnum:]]. The uppercase forms match the complements of these sets. In a negated form, the caret inside the bracket is the negation marker, so \D is the complement of \d and matches anything that is not a decimal digit.

The class \w is the one most often misread, because its name suggests letters alone. The definition covers three things: a letter from a to z, a digit from 0 to 9, and an underscore. The expansion [_[:alnum:]] combines the underscore with the alphanumeric class. A learner who reads \w as just letters will be surprised when a digit or an underscore matches.

Beyond the standard shorthand, languages that support regular expressions often provide additional abbreviations. These are described as nonstandard but common. The lowercase and uppercase forms are \l and \u, and their negations are \L and \U. The escape \l stands for a lowercase character, which corresponds to the standard class [[:lower:]], and \u stands for an uppercase character, which corresponds to [[:upper:]].

Standard and nonstandard forms can describe the same set of characters within a given language, but only the standard names carry a guarantee that a pattern reads the same way across tools. The shorthand \d and the class [[:digit:]] are the portable pair. The escape \l depends on the language offering that abbreviation, so a pattern that uses it may not behave the same elsewhere.