Greedy and Lazy Quantifiers: Controlling How Much to Match

The * quantifier matches zero or more characters, while + matches one or more characters.

Programming

Why One Character Is Not Enough

Text between two known markers is rarely a fixed length. In the source examples, the text after From: can be alice or stephen.marquard before the at-sign appears. A single wildcard matches only one character, so it cannot cover both cases. Quantifiers let a regular expression repeat a matching pattern across variable-length text.

What changes when the repeated pattern is allowed to occur zero times instead of requiring at least one occurrence?

Reading the Quantifiers

Definition

The * quantifier matches zero or more characters. The + quantifier matches one or more characters. The difference is whether the repeated part may be absent.

The dot wildcard matches any single character except a newline. Placing + after the dot creates .+, which means one or more characters in a row. This is useful when the amount of text between two known markers varies. For example, .+ can cover the different lengths of alice and stephen.marquard before an at-sign.

How does .+ consume the characters between an opening marker and a closing marker?

Worked example

Matching Text Before an At-Sign

Use the pattern ^From:.+@ to identify the beginning of a line that starts with From: and contains an at-sign.

1
Start at the line beginning
The beginning anchor requires the match to start at the beginning of the line.
2
Match the fixed marker
From: matches the literal beginning marker.
3
Expand .+
The dot matches one character at a time, and + requires at least one such character. The repeated part covers the variable-length text before the at-sign.
4
Reach the at-sign
The complete pattern succeeds when the expanded .+ is followed by the required at-sign.

Result

The pattern is suitable for lines such as From: stephen.marquard@uct.ac.za because it matches From:, variable-length content, and then the at-sign.

Following Greedy Expansion

Regular expression engines use greedy matching by default. When the engine reaches a quantifier such as +, it does not know in advance how many characters are needed. It expands the repeated pattern as far as possible while still allowing the overall pattern to succeed.

How does a greedy quantifier grow one character at a time while preserving the possibility of matching the rest of the pattern?

What do you think happens?

For the pattern ^From:.+@ applied to From: alice@, what role does .+ play?

It matches no characters
It matches exactly one character
It matches the variable-length text between From: and @
It matches only the at-sign

Reveal answer

Answer:

It matches the variable-length text between From: and @.

The dot matches a character, and + requires one or more repetitions. The pattern therefore covers alice before the required at-sign.

Greedy Behavior and Lazy Scope

Behavior covered by the source	What it means
Greedy matching	The engine expands a quantifier as far as possible while still allowing the overall pattern to succeed.
Lazy quantifier behavior	The supplied material does not define its syntax or stopping rule, so those details are not specified here.

The source material provides a detailed rule for greedy matching but does not provide enough information to state a grounded rule for lazy quantifiers.

What can be concluded from the supplied material about greedy and lazy quantifiers?

Debugging Quantifier Choices

When a pattern does not match as expected, first ask whether the repeated content is required. If at least one character must occur between the markers, + expresses that requirement. If an empty span is valid, * permits it. Then inspect the marker that follows the quantifier: greedy matching expands until the rest of the pattern can succeed, so the position of that marker helps determine where the repeated portion ends.

Which part of the pattern changes when empty content becomes either acceptable or invalid?

Common mistake
Using a single dot when the text between markers can vary in length.
What it looks like
A single dot can match one character, but it cannot cover both alice and stephen.marquard.
Why it fails
The wildcard is being used without a quantifier, so it does not repeat.
Do this instead
Use .+ when at least one character must appear between the markers.
Common mistake
Using + when the valid input may contain no characters between the markers.
What it looks like
A pattern requiring + will not accept an empty span between the markers.
Why it fails
The plus quantifier requires one or more characters.
Do this instead
Use * when zero characters is acceptable.
Common mistake
Assuming a greedy quantifier has a fixed length.
What it looks like
The .+ portion does not always consume the same number of characters.
Why it fails
The engine expands the quantifier according to the available text and the rest of the pattern.
Do this instead
Find the following required marker and reason about how far the quantifier can expand while the complete pattern still succeeds.
Common mistake
Treating the terms greedy and lazy as interchangeable.
Why it fails
The supplied material specifically defines greedy matching but does not specify lazy quantifier syntax or behavior.
Do this instead
Use the grounded rule in this lesson: greedy matching expands as far as possible while the overall pattern can still succeed.

Best practice

Choose the quantifier from the data requirement, not from habit. Use + when content must be present. Use * when an empty span is valid. For variable-length content between known markers, combine the dot wildcard with the quantifier and then inspect how greedy expansion interacts with the following marker.

Apply the Matching Rules

EASY

For each situation, decide whether * or + expresses the requirement. First, the markers may have nothing between them. Second, the markers must have at least one character between them. Third, the text between From: and @ may have different lengths, as in alice and stephen.marquard.

Hints

Ask whether zero characters is valid.
Remember that .+ combines the dot wildcard with the one-or-more requirement.
For the From: examples, identify the fixed markers and the variable-length region.

Your attempt (not saved)

Worked example

Reasoning About a Variable-Length Region

Explain why ^From:.+@ is more suitable than a single wildcard for a line such as From: stephen.marquard@uct.ac.za.

1
Identify the fixed beginning
The line begins with From:, and the beginning anchor requires matching at the start of the line.
2
Identify the changing region
The text before the at-sign can have different lengths, so one wildcard character is insufficient.
3
Apply the quantifier
The + after the dot allows one or more characters to occur in sequence.
4
Check the required marker
The at-sign follows the variable region, giving the greedy match a concrete condition for the overall pattern to succeed.

Result

The pattern uses fixed text, a variable-length .+ region, and the at-sign to describe the required structure.

Essential Takeaways

1
The * quantifier matches zero or more characters.
2
The + quantifier matches one or more characters, so it requires content to be present.
3
The .+ pattern matches one or more characters and is useful for variable-length content between known markers.
4
Greedy matching expands a quantifier as far as possible while still allowing the overall pattern to succeed.
5
When debugging, check whether the quantifier should permit an empty span and which required marker limits the greedy expansion.

At a glance

Use * for zero or more characters and + for one or more characters.
Use .+ when variable-length content must occur between two known markers.
Greedy matching expands the repeated pattern as far as possible while the complete pattern can still succeed.
Debug quantifier problems by checking the minimum content requirement and the marker that follows the quantifier.
The supplied material explains greedy matching but does not specify lazy quantifier syntax or behavior.

Related concepts

More concepts starting with G