Introduction

To match everything up to a specific sequence in a regular expression, the usual pattern is a lazy match followed by a lookahead. That combination lets you stop right before the delimiter instead of consuming it.

The Standard Pattern

A common solution is:

.*?(?=SEQUENCE)

This works because:

• '.*? matches as few characters as possible'
• '(?=SEQUENCE) asserts that the target sequence appears next'
• the lookahead checks the delimiter without including it in the match

If the input is alpha beta END gamma, the pattern .*?(?=END) matches alpha beta .

Why Greedy Matching Fails

A plain greedy pattern such as .*END behaves differently.

.*END

That pattern consumes through the delimiter, and if the input contains multiple occurrences it may run farther than you intended before backtracking.

The lazy version is usually safer when the goal is "stop at the first occurrence of this sequence."

Example In Python

Here is a simple Python example using a capturing group.

1import re
2
3text = "header: value END trailer"
4match = re.search(r"(.*?)(?=END)", text)
5
6if match:
7    print(match.group(1))

Output:

header: value 

The important part is that END is still available in the original string because the lookahead did not consume it.

Match Including The Delimiter When Needed

Sometimes you want everything up to and including the sequence. In that case, do not use a lookahead. Match the delimiter directly.

.*?END

That would match alpha beta END instead of stopping just before END.

So the first design choice is whether the delimiter belongs in the match result.

A Character Class Can Be Better For Simple Delimiters

If the stopping point is a single character or a small, simple set of characters, a negated character class is often faster and easier to read.

[^;]*

That pattern matches everything up to the first semicolon. It is usually simpler than .*?(?=;) when the delimiter is a single literal character.

Newlines Change The Behavior Of .

In many regex engines, . does not match newline characters unless a dot-all mode is enabled. If the text can span multiple lines, your pattern may appear to stop unexpectedly.

In Python, for example, you can enable dot-all with re.S:

1import re
2
3text = "line one\nline two\nEND"
4match = re.search(r".*?(?=END)", text, re.S)
5
6if match:
7    print(match.group(0))

Without dot-all, . usually stops at the first newline.

Escape The Sequence If It Is Literal Text

If the sequence contains regex metacharacters, escape it before inserting it into the pattern. For example, matching up to a+b requires different handling from matching up to a plain alphabetic word.

In Python:

1import re
2
3sequence = re.escape("a+b")
4pattern = rf".*?(?={sequence})"
5print(re.search(pattern, "test a+b tail").group(0))

Using re.escape avoids accidental regex behavior when the delimiter should be treated as ordinary text.

Common Pitfalls

A common mistake is using .* instead of .*? and then being surprised when the regex captures too much before backtracking.

Another mistake is forgetting that . often excludes newline characters. Multi-line input may require dot-all mode or a different character class strategy.

It is also easy to use a lookahead when you actually need to consume the delimiter. Decide first whether the target sequence should remain outside the match.

Summary

• Use .*?(?=SEQUENCE) to match up to, but not including, a sequence.
• Use .*?SEQUENCE if you want the delimiter included in the match.
• Prefer lazy quantifiers when you want the first occurrence.
• For simple single-character delimiters, a negated character class can be cleaner.
• Watch for newline behavior because . may not span lines by default.