Understanding positive and negative lookaheads

41
votes

I'm trying to understand how negative lookaheads work on simple examples. For instance, consider the following regex:

a(?!b)c

I thought the negative lookahead matches a position. So, in that case the regex matches any string that contains strictly 3 characters and is not abc.

But it's not true, as can be seen in this demo. Why?

4
regexregex-lookarounds
Maybe this can help: regular-expressions.info/lookaround.html – Rocket Hazmat
@RocketHazmat Yes, it's helpful, but it was the first result in the google :) I've read it – St.Antario
To add to this problem, a common misconception is that you can use negative lookaheads to substitute for multi-word negation or even attempt otherwise, so you will see broken regexes like these: [A-Za-z]+(?![A-Za-z]), [^sword]fish, (?!sword)fish – Unihedron

4 Answers

50
votes

Lookaheads do not consume any characters. It just checks if the lookahead can be matched or not:

a(?!b)c

So here after matching a it just checks if it is followed not by b but does not consume that not character (which is c) and is followed by c.

How a(?!b)c matches ac

ac
|
a

ac
 |
(?!b) #checks but does not consume. Pointer remains at c

ac
 |
 c

Positive lookahead

The positive lookahead is similar in that it tries to match the pattern in the lookahead. If it can be matched, then the regex engine proceeds with matching the rest of the pattern. If it cannot, the match is discarded.

E.g.

abc(?=123)\d+ matching abc123

abc123
|
a

abc123
 |
 b

abc123
  c

abc123 #Tries to match 123; since is successful, the pointer remains at c
    |
 (?=123)

abc123 # Match is success. Further matching of patterns (if any) would proceed from this position
  |

abc123
   |
  \d

abc123
    |
   \d

abc123 #Reaches the end of input. The pattern is matched completely. Returns a successfull match by the regex engine
     |
    \d
8
votes

@Antario, I was confused about the negative look ahead/behind case in regex for a while and this site has a great explanation.

So with your example what you are saying is that you have a literal "a" and it is NOT followed by a literal "b" and it IS followed by a literal "c".

Here is a different regex debugger than you used which gives a more visual answer which personally I find helpful :)

a(?!b)c

Regular expression visualization

Debuggex Demo

3
votes

a(?!b)c will match only ac because the only way you'll have an a followed by "not b" (which will not be consumed) and then c, is ac.

2
votes

So, in that case the regex matches any string that contains strictly 3 characters and is not the abc

This is not quite right. This regex states that we are searching a sequence which firstsymbol is a and after that is c, and inside there is no b.

For example, a(?!b). will match either ac or af as there is no restrictions on the last symbol via .