regex negative

Guri Bee

2 min read

·

18-10-2024

1

0

Share

Mastering the Art of Negative Lookarounds in Regex: Finding What You Don't Want

Regular expressions, or regex, are powerful tools for pattern matching in text. But sometimes, you need more than just matching a specific pattern. You might want to find something that doesn't match a certain pattern. This is where negative lookarounds come into play.

What are Negative Lookarounds?

Negative lookarounds are a powerful feature of regex that let you assert the absence of a pattern. They are zero-width assertions, meaning they don't consume characters but rather check for the presence (or absence) of a pattern at a specific location.

Types of Negative Lookarounds

There are two main types of negative lookarounds:

1. Negative Lookahead (?!): This checks for the absence of a pattern after the current position. It makes sure the pattern following the current position doesn't match the given pattern.
2. Negative Lookbehind (?<!): This checks for the absence of a pattern before the current position. It ensures that the characters preceding the current position don't match the given pattern.

Practical Examples: Where Negative Lookarounds Excel

1. Extracting Phone Numbers:

   Let's say you have a text file with phone numbers, but some numbers are preceded by "Phone:" and others are not. We can use negative lookbehind to extract only those phone numbers that are not preceded by "Phone:":

   (?<!Phone:)\d{3}-\d{3}-\d{4}
   

   • (?<!Phone:): This ensures that "Phone:" doesn't appear before the match.
   • \d{3}-\d{3}-\d{4}: This matches the standard phone number pattern.

2. Finding HTML Tags Without Specific Attributes:

   You can use negative lookahead to find all <img> tags without a src attribute:

   <img(?!.*src=).*?>
   

   • <img: Matches the opening of the <img> tag.
   • (?!.*src=): This ensures that the src attribute is not present within the tag.
   • .*?>: Matches any content within the tag, including the closing tag.

3. Identifying Words that Don't Start With a Specific Letter:

   If you want to find all words in a text that don't start with the letter "A", you can use negative lookahead:

   \b(?!A)\w+\b
   

   • \b: Matches word boundaries.
   • (?!A): Ensures the word doesn't start with the letter "A".
   • \w+: Matches one or more word characters.

Important Considerations

• Lookbehinds must have fixed-width patterns: The pattern used in lookbehind assertions needs to have a fixed length. This means you can't use quantifiers like * or + within lookbehinds, as the length of the match would vary.
• Performance implications: Regex with lookarounds, especially lookbehinds, can be slower than simple pattern matching. Use them strategically when the benefits outweigh the potential performance hit.

Adding Value Beyond Github:

While Github is a fantastic resource for learning regex, many discussions lack contextualization and real-world examples. This article aims to bridge this gap by providing practical scenarios where negative lookarounds shine. By highlighting the types of problems they solve and offering detailed explanations with code examples, we hope to empower users to confidently apply this powerful tool.

Remember, regex is a language of its own. Practice, explore, and experiment to master the art of negative lookarounds.

Further Exploration:

• Regex101 - A fantastic website for testing and visualizing regular expressions.
• Regular Expressions: The Complete Tutorial - Comprehensive resource covering all aspects of regex.
• Stack Overflow - A vast repository of regex questions and answers.

Author:

• Original Github source: This article has been created by drawing inspiration from various discussions on Github, which are too numerous to cite individually. This article aims to synthesize and expand upon those conversations, providing a more comprehensive and user-friendly guide to negative lookarounds.