Introduction

To match lines that do not contain a pattern using grep, use the -v (or --invert-match) flag. This inverts the match logic so that grep prints only the lines that fail to match the given pattern. It works with fixed strings, basic regular expressions, and extended regular expressions, and it composes cleanly with every other grep option.

grep -v "foo" file.txt

That single flag is the answer, but the rest of this article covers the practical situations where negative matching gets more nuanced: excluding multiple patterns, combining with case-insensitive search, filtering structured data, and handling edge cases in scripts and pipelines.

How -v Works

The -v flag inverts the exit behavior and output of grep. Without -v, grep prints lines that match. With -v, it prints lines that do not match.

Consider a file servers.txt:

1web-server-01  running
2db-server-01   running
3web-server-02  stopped
4cache-server   running
5db-server-02   stopped

To show only lines that do not contain "stopped":

grep -v "stopped" servers.txt

Output:

web-server-01  running
db-server-01   running
cache-server   running

The matched pattern is excluded. Everything else passes through.

Excluding Multiple Patterns

When you need to exclude more than one pattern, you have several options.

Using Multiple -e Flags

grep -v -e "stopped" -e "cache" servers.txt

Output:

web-server-01  running
db-server-01   running

Each -e adds a pattern to the match set, and -v inverts the entire combined result. A line is excluded if it matches any of the listed patterns.

Piping Multiple grep -v Commands

cat servers.txt | grep -v "stopped" | grep -v "cache"

This produces the same result. Chaining is sometimes clearer when filters are built dynamically in a script, but it spawns multiple processes.

Using Extended Regex Alternation

grep -vE "stopped|cache" servers.txt

The -E flag enables extended regular expressions, and the pipe character acts as logical OR. This is the most compact form for excluding multiple fixed strings.

Combining With Other grep Options

The -v flag composes with every other grep option. Here are the most useful combinations.

Case-Insensitive Negative Match

grep -vi "error" application.log

This excludes lines containing "error", "Error", "ERROR", or any other case variation.

Counting Excluded Lines

grep -vc "foo" data.txt

The -c flag prints the count of matching lines. Combined with -v, it counts lines that do not contain the pattern.

Showing Line Numbers

grep -vn "DEBUG" application.log

The -n flag prepends line numbers, which is useful when you need to locate the non-matching lines in context.

Whole-Word Matching

grep -vw "to" sentences.txt

Without -w, the pattern "to" would also match inside words like "tomato" or "together". The -w flag requires the pattern to appear as a whole word, so -vw "to" excludes only lines containing the standalone word "to".

Negative Matching With Regular Expressions

The real power of negative matching shows up when combined with regex patterns.

Exclude Lines Starting With a Comment

grep -v "^#" config.conf

This filters out comment lines in configuration files (lines beginning with #).

Exclude Blank Lines

grep -v "^$" file.txt

Combined with comment removal:

grep -v "^#" config.conf | grep -v "^$"

Or in a single expression:

grep -vE "^#|^$" config.conf

This is a common pattern for extracting only the meaningful content from configuration files.

Exclude Lines Matching a Complex Pattern

grep -vE "^[0-9]{4}-[0-9]{2}-[0-9]{2}.*DEBUG" application.log

This excludes timestamped DEBUG log lines while keeping everything else. The regex matches a date-like prefix followed by the word "DEBUG" anywhere on the line.

Practical Use Cases

Filtering Log Files

1# Show all log entries except INFO-level messages
2grep -v "INFO" /var/log/app.log
3
4# Show errors only by excluding everything else
5grep -vE "INFO|DEBUG|TRACE" /var/log/app.log

Cleaning Process Lists

# List Java processes, excluding the grep process itself
ps aux | grep java | grep -v "grep"

This is a classic pattern. When you grep for a process name, the grep command itself shows up in the ps output. The trailing grep -v "grep" removes that false positive.

Filtering CSV or TSV Data

1# Remove header and empty lines from a CSV
2tail -n +2 data.csv | grep -v "^$"
3
4# Exclude rows where the third field is "N/A"
5awk -F',' '{print}' data.csv | grep -v ",N/A,"

Validating File Contents in CI

1# Fail if any source file contains a TODO
2if grep -r "TODO" src/; then
3  echo "Found TODO comments. Clean up before merging."
4  exit 1
5fi

The inverse check (ensuring something is absent) is what negative matching enables in automated validation.

Reference Table

Note: grep -L (uppercase L) is equivalent to grep --files-without-match and directly lists files that do not contain the pattern, without needing -v.

Common Pitfalls

Forgetting that -v inverts the entire combined pattern set is a frequent source of confusion. When using grep -v -e "foo" -e "bar", a line is excluded if it matches either pattern, not only if it matches both. If you need to exclude lines that contain both "foo" and "bar" simultaneously, you need a different approach (a regex like grep -v "foo.*bar\|bar.*foo" or a pipeline with awk).

Using -v without anchoring patterns can produce unexpected results. For instance, grep -v "log" will also exclude lines containing "catalog", "dialog", or "login". Use -w for whole-word matching or anchor with \b word boundaries.

Neglecting the grep self-match problem in process listings (ps aux | grep pattern) is a classic mistake. Always add | grep -v grep or use pgrep instead.

Assuming -v affects the exit code the same way as normal matching can break scripts. With -v, grep returns exit code 0 if any lines did not match (were printed) and 1 if all lines matched (nothing printed). Script conditions need to account for this inversion.

Not quoting patterns that contain shell metacharacters (like |, *, ?) leads to the shell expanding them before grep sees them. Always quote your patterns.

Summary

• Use grep -v "pattern" to print lines that do not contain a pattern.
• Exclude multiple patterns with -e flags, piped commands, or extended regex alternation (-vE "a|b").
• Combine -v with -i (case-insensitive), -w (whole word), -n (line numbers), or -c (count) as needed.
• Use grep -L to list files that do not contain a pattern at all.
• Watch out for unanchored patterns matching inside longer words, and always quote patterns to prevent shell expansion.