How to use grep command in Linux / UNIX

The grep is a versatile command-line utility found in Unix-based systems (Linux, macOS) for searching and processing text. Its core function is to scan text files or input streams for lines matching a specified pattern. It's efficient and lightweight, making it popular for tasks like finding specific information in log files, checking configuration files for errors, analyzing code for keywords, and performing basic data filtering.

With various options such as case-insensitive search, displaying line numbers, recursive directory search, and support for regular expressions, grep offers powerful and flexible text-search capabilities. Whether you're troubleshooting, debugging, or analyzing data, grep is a valuable tool in the Unix command-line toolkit.

Basic Syntax:

The basic syntax of grep is as follows:

grep [options] pattern [file(s)]
  1. options:Optional flags that modify the behavior of grep.
  2. pattern:The regular expression (regex) or simple string to search for.
  3. file(s):The file or files in which to search. If not provided, grep reads from standard input.

Key Options:

  1. -i:enables case-insensitive search with grep, allowing it to match patterns regardless of letter case. For instance, grep -i 'error' file.txt finds "error", "Error", and "ERROR" within the specified file.
  2. -v:inverts the match, showing lines that do not contain the specified pattern when used with grep. It helps filter out lines that do not meet the search criteria.
  3. -c:option with grep counts occurrences of the specified pattern in each file. This is useful for obtaining a quick count of how many times a particular pattern appears.
  4. -n:with grep prints line numbers along with matching lines, aiding in locating patterns within files. For example, grep -n 'error' file.txt shows line numbers for lines containing "error."
  5. -r:in grep allows for recursive searching through directories, exploring all files within the specified directory and its subdirectories.
  6. -w:restricts matches to whole words only. For instance, grep -w 'error' file.txt won't find "errors" or "erroneous," ensuring exact word matches in the search process.


Searching for a simple string:
grep "example" file.txt

This searches for the string "example" in the file.txt and prints lines containing the match.

Case-insensitive search:
grep -i "pattern" file.txt

The -i option makes the search case-insensitive.

Displaying line numbers:
grep -n "pattern" file.txt

The -n option displays line numbers along with matching lines.

Recursive search in directories:
grep -r "pattern" directory/

The -r option searches recursively through all files in the specified directory.

Inverting the match:
grep -v "pattern" file.txt

The -v option inverts the match, displaying lines that do not contain the specified pattern.

Counting occurrences:
grep -c "pattern" file.txt

The -c option counts and prints the number of lines that match the pattern.

Searching for multiple patterns:
grep -e "pattern1" -e "pattern2" file.txt

You can use multiple -e options to search for multiple patterns.

Searching for whole words:
grep -w "word" file.txt

The -w option matches whole words, preventing partial matches.

Using grep with pipelines:
cat file.txt grep "pattern"

You can use grep with other commands through pipelines to filter text.

Displaying context around matches:
grep -C 2 "pattern" file.txt

The -C option shows two lines of context around each match.

Regular Expressions | grep

The grep command supports powerful regular expressions (regex) for advanced pattern matching, enabling flexible searches based on specific characters, ranges, and groups. The regex syntax includes wildcards for repetition or variation and special characters like "." (representing any character), "^" (indicating the beginning of a line), and "$" (denoting the end of a line). This robust regex support enhances grep's capabilities, allowing users to perform intricate text searches and extractions with precision and efficiency.

Examples :

Let's consider an example where we have a file named example.txt with the following content:

1. This line contains an error 2. No errors found in this file 3. Vowels are a, e, i, o, u 4. 12345 is a sequence of digits 5. No issues to report

Now, let's apply the mentioned grep commands:

grep 'e.ror$' example.txt:
$ grep 'e.ror$' example.txt
#Output: This line contains an error

This command finds and displays the line ending with "error," as it matches the specified pattern.

grep '[aeiou]' example.txt:
$ grep '[aeiou]' example.txt
#Output: Vowels are a, e, i, o, u

This command locates and prints the line containing any vowel from the set [aeiou].

grep '\d+' example.txt:
$ grep '\d+' example.txt
#Output: 12345 is a sequence of digits

This command identifies and displays the line with one or more digits, as the pattern '\d+' matches the numeric sequence '12345.'

Error Handling:

  1. Ensure the pattern is correctly enclosed in quotes.
  2. Verify file paths and permissions.
  3. Use clear and meaningful patterns to avoid ambiguous matches.
  4. Test your commands on small datasets before applying them to large ones.


grep is a command-line utility in Unix-based systems for searching and processing text. It efficiently scans files or input streams, using powerful pattern-matching techniques such as regular expressions to find and manipulate text based on user-defined criteria.