How to negate specific word in regex?

Mastering Negative Lookaheads in Regex

Learn how to effectively use negative lookaheads in regular expressions to match patterns that DO NOT contain specific words or phrases.

Regular expressions are powerful tools for pattern matching, but sometimes you need to match a string that doesn't contain a particular word or sequence. This is where negative lookaheads come into play. A negative lookahead is a zero-width assertion that asserts that a pattern does not match at a certain point. It's a crucial technique for more precise and nuanced regex operations.

Understanding Negative Lookaheads

A negative lookahead is denoted by (?!...). It's a non-capturing group that, when encountered, checks if the pattern inside it ... does not match immediately after the current position. If it matches, the entire regex fails at that point. If it doesn't match, the regex engine continues. It's 'zero-width' because it doesn't consume any characters; it merely asserts a condition.

Consider a scenario where you want to find all lines that contain 'error' but not 'fatal error'. A simple search for 'error' would include both. A negative lookahead allows you to exclude the 'fatal error' case.

(?!word)pattern

This regex attempts to match 'pattern' only if 'word' does not immediately follow the current position.

Negating a Word Anywhere in a String/Line

One common use case is to match an entire line or string that does not contain a specific word. To achieve this, you combine a negative lookahead with a character class that matches any character (.) and a quantifier (*). The pattern ^((?!word).)*$ will match any string that does not contain 'word'. Let's break it down:

• ^: Matches the beginning of the string.
• ((?!word).)*: This is the core. It repeatedly matches any character (.) as long as 'word' is not present immediately after the current position. The (?!word) ensures that 'word' is not found.
• $: Matches the end of the string.

This construction ensures that for every character matched, the negative lookahead checks that 'word' isn't about to appear. If 'word' is found, the lookahead fails, and the engine backtracks, eventually failing the entire match for that string.

^((?!fatal error).)*error((?!fatal error).)*$

Matches lines containing 'error' but not 'fatal error'. This is a more robust example for specific scenarios.

^(?!.*\bforbidden\b).*$

Matches any line that does not contain the whole word 'forbidden'.

Combining with Other Patterns

Negative lookaheads can be combined with other regex components to create highly specific patterns. For instance, you might want to find all email addresses that are not from a specific domain.

Example: Find all lines containing 'log' but not 'debug log'.

Logic Flow of a Negative Lookahead

import re

text = [
    "This is an error message.",
    "This is a fatal error message.",
    "Another error occurred.",
    "Just a normal line."
]

# Match lines containing 'error' but not 'fatal error'
pattern = r"^((?!fatal error).)*error.*$"

for line in text:
    if re.search(pattern, line):
        print(f"MATCHED (Python): {line}")

Python script demonstrating how to use a negative lookahead to filter lines.

const text = [
    "This is an error message.",
    "This is a fatal error message.",
    "Another error occurred.",
    "Just a normal line."
];

// Match lines containing 'error' but not 'fatal error'
const pattern = /^(?!.*fatal error).*error.*$/;

text.forEach(line => {
    if (pattern.test(line)) {
        console.log(`MATCHED (JavaScript): ${line}`);
    }
});

JavaScript code snippet using a negative lookahead.

Practical Steps for Constructing Negative Lookahead Regex

Follow these steps to build your own regex with negative lookaheads:

1. Step 1

Identify the word or phrase to negate: Determine exactly what you do not want to match (e.g., 'forbidden', 'admin_only').

2. Step 2

Choose the scope: Decide if you want to negate the word from an entire line, a specific part of a string, or only if it appears immediately after another pattern.

3. Step 3

Construct the negative lookahead: Use (?!your_word) for immediate negation or (?!.*your_word) for negation anywhere later in the string.

4. Step 4

Integrate with your main pattern: Place the negative lookahead strategically. For negating a word in an entire line, ^(?!.*your_word).*$ is common. For negating a word that appears after another pattern, place the lookahead after that pattern.

5. Step 5

Test thoroughly: Use online regex testers or your programming language's regex engine with various test cases, including cases that should match and cases that should not.