Positive Lookahead Doesn't Stop at First Occurrence

Positive lookahead doesn't stop at first occurrence

An easy way is to use the non-greedy operator.

(?<=Charset:\s).+?(?=<br\/>)

Regex LookAhead limit to one (or first match)

You should make the main part not-greedy by using

 .*? instead of .*

Regex: Capturing first occurrence before lookahead

You can use some laziness:

^(.*?:\/\/).*?/(?=dinner/?)

Live demo

By using a .* in the middle of your regex you ate everything until the last colon, where it found a match.

.* in the middle of a regex, by the way, is very bad practice. It can cause horrendous backtracking performance degradation in long strings. .*? is better, since it is reluctant rather than greedy.

regex to match the first lookbehind only

In Java you can use this regex with negative lookahead:

(?s)\bSymptom Correlation to Reflux\b((?:(?!Symptom Correlation to Reflux).)*?)\bReflux Symptom Index\b

Java code:

Pattern p = Pattern.compile(
"(?s)\\bSymptom Correlation to Reflux\\b((?:(?!Symptom Correlation to Reflux).)*?)\\bReflux Symptom Index\\b");

table is available in captured group #1

(?:(?!Symptom Correlation to Reflux).)*? is negative lookahead assertion to ensure that we don't match another Symptom Correlation to Reflux in the middle of start/end.

RegEx Demo

Positive lookahead not working as expected

Lookahead does not consume the string being searched. That means that the [ s] is trying to match a space or s immediately following black. However, your lookahead says that hand must follow black, so the regular expression can never match anything.

To match either blackhands or blackhand while using lookahead, move [ s] within the lookahead: black(?=hand[ s]). Alternatively, don't use lookahead at all: blackhand[ s].

Why doesn't positive lookahead work as first capture group?

Change your regex like below and then grab the strings you want from group index 1 and 2.

(?:_missing_:|_exists_:)([a-z1-9]+)|([a-z1-9]+)(?=:)

You don't need to include the non-capturing group (?:_missing_:|_exists_:) inside a capturing group. This is the reason for returning missing:title instead of title . And also Capturing group for [a-z1-9]+ would be enough.

DEMO

How to make my regex match stop after a lookahead?

Something like:

list = re.findall(r"^\d+\..*?(?=^\d+\.|\Z)", text, re.MULTILINE | re.DOTALL)

Further explanation on request.

Combining positive and negative lookahead in python

You can use

^(?!=.*[_.:;\-\\\/@+*]{2})(?=[^\d\n]*\d)[\w.:;\-\\\/@+*]+$

Regex demo

The negative lookahead (?=[^\d\n]*\d) matches any char except a digit or a newline use a negated character class, and then match a digit.

Note that you also have to add * and that most characters don't have to be escaped in the character class.

Using contrast, you could also turn the first .* into a negated character class to prevent some backtracking

^(?!=[^_.:;\-\\\/@+*\n][_.:;\-\\\/@+*]{2})(?=[^\d\n]*\d)[\w.:;\-\\\/@+*]+$

---

Edit

Without the anchors, you can use whitespace boundaries to the left (?<!\S) and to the right (?!\S)

(?<!\S)(?!=\S*[_.:;\-\\\/@+*]{2})(?=[^\d\s]*\d)[\w.:;\-\\\/@+*]+(?!\S)

Regex demo

Excluding the positive lookahead from the capture group

The .* consumes the <path> and <paths> that are checked for with your lookahead. Look, (?=<path>|<paths>)(.*) in your regex first checks if there is <path> or <paths> immediately to the right of the current location and if there is, (.*) readily consumes (=adds the matched text to the overall match value and advances the regex index to the end of the current subpattern match) the <path> or <paths> since .* matches zero or more chars other than line break chars, as many as possible.

Make the lookahead pattern consuming:

^\s*(?:<path>|<paths>)(.*)$

See the regex demo.

Or, remove the alternation and contract the pattern to:

^\s*<paths?>(.*)$

See this regex demo. Here, <paths?> matches <path, then an optional s char and then a >.

---

Related Topics