Lazy Patterns

Many learners meet regular expressions and conclude that they are a kind of code that only its author can ever read. A single line can hold a dense cluster of symbols, and once it is written, it seems to resist any later review. The source for this topic names this belief directly: regular expressions can easily become a write-only language. The useful question is not whether that danger exists, but what habits keep a pattern readable and what the notation itself gives you to work with.

Before reading further, pause and ask yourself: what would make a pattern easy for a future reader to understand, and what would make it impossible? Keep your answer in mind. The rest of this article tests that intuition against what the source gives.

The default regular expression notation described in this topic is that of ECMAScript. Unless you choose otherwise, the rules you are reading are the ECMAScript rules.

The notation is not fixed to that one default. The source states that it can be adjusted to match various standards. The same general idea of a pattern can therefore be expressed under different notational conventions, and you select the convention that your situation requires. What changes between conventions is the set of rules for reading the symbols, not the underlying idea of describing text by pattern.

The belief that regular expressions are unreadable is partly true, because a regular expression packs a lot of meaning into very few characters. A reader has to recognize each symbol, understand how symbols combine, and keep track of which part of the pattern each character belongs to. When a pattern grows without discipline, these combinations become hard to follow, even for the person who wrote them.

The practical correction is restraint. Do not write the most compact pattern that happens to work. Write the pattern that a later reader can verify at a glance. The source gives this as a tip for using regular expressions effectively, and it applies to every pattern you write, whether short or long.

The notation includes \i, which the source describes as allowing you to express a subpattern in terms of a previous subpattern. Instead of spelling out the same subpattern again, you refer back to an earlier one. The result reads as a composition of named ideas rather than one long sequence of symbols.

The source gives one specific modifier: the question mark ?. Placing ? in a pattern makes that pattern lazy. A lazy pattern matches as little text as it can while still satisfying the pattern, as opposed to matching as much as possible. Because the modifier is a single symbol, the change it makes is easy to overlook when you read a pattern.

To see the difference concretely, consider a generated illustration. Suppose the input text is the string <b>one</b> and <b>two</b>, and the pattern is written as <b>.*</b> with the star matching as much as possible, compared with <b>.*?</b> where the question mark makes the pattern lazy. The diagram below shows where each version ends its match on the same input. This is an original illustration of the lazy-versus-greedy idea the source describes, not an example taken from the source.

In the greedy version, one match covers everything from the first opening tag through the last closing tag. In the lazy version, the match stops at the first place the pattern can be satisfied, so the same input yields two separate matches. The question mark did not change the characters being searched for; it changed how much text each match is allowed to take.

Regular expressions are not only used to test a single string. The source explains that you can use regex iterators to iterate over a stream while looking for a pattern. The pattern is applied repeatedly as you move through a stream of text, and each match the iterator finds is a point where your program can act.