Linux search for a word in a file

Introduction

This guide details the most useful grep commands for Linux / Unix systems.

After going through all the commands and examples, you will learn how to use grep to search files for a text from the terminal.

Prerequisites

• Linux or UNIX-like system
• Access to a terminal/command line
• A user with permissions to access the desired files and directories

What is the grep Command?

Grep is an acronym that stands for Global Regular Expression Print.

Grep is a Linux / Unix command-line tool used to search for a string of characters in a specified file. The text search pattern is called a regular expression. When it finds a match, it prints the line with the result. The grep command is handy when searching through large log files.

Using the grep Command

The grep command consists of three parts in its most basic form. The first part starts with grep, followed by the pattern that you are searching for. After the string comes the file name that the grep searches through.

The simplest grep command syntax looks like this:

The command can contain many options, pattern variations, and file names. Combine as many options as necessary to get the results you need. Below are the most common grep commands with examples.

To Search a File

To print any line from a file that contains a specific pattern of characters, in our case phoenix in the file sample2, run the command:

grep phoenix sample2

Grep will display every line where there is a match for the word phoenix. When executing this command, you do not get exact matches. Instead, the terminal prints the lines with words containing the string of characters you entered. Here is an example:

To Search Multiple Files

To search multiple files with the grep command, insert the filenames you want to search, separated with a space character.

In our case, the grep command to match the word phoenix in three files sample, sample2, and sample3 looks like this example:

grep phoenix sample sample2 sample3

The terminal prints the name of every file that contains the matching lines, and the actual lines that include the required string of characters.

You can append as many filenames as needed. The terminal prints a new line with the filename for every match it finds in the listed files.

Search All Files in Directory

To search all files in the current directory, use an asterisk instead of a filename at the end of a grep command.

In this example, we use nix as a search criterion:

grep nix *

The output shows the name of the file with nix and returns the entire line.

To Find Whole Words Only

Grep allows you to find and print the results for whole words only. To search for the word phoenix in all files in the current directory, append -w to the grep command.

grep -w phoenix *

This option only prints the lines with whole-word matches and the names of the files it found them in:

When -w is omitted, grep displays the search pattern even if it is a substring of another word.

If you would like to search for multiple strings and word patterns, check out our article on how to grep for multiple strings, patterns or words.

To Ignore Case in Grep Searches

As grep commands are case sensitive, one of the most useful operators for grep searches is -i. Instead of printing lowercase results only, the terminal displays both uppercase and lowercase results. The output includes lines with mixed case entries.

An example of this command:

grep -i phoenix *

If we use the -i operator to search files in the current directory for phoenix, the output looks like this:

To Search Subdirectories

To include all subdirectories in a search, add the -r operator to the grep command.

grep -r phoenix *

This command prints the matches for all files in the current directory, subdirectories, and the exact path with the filename. In the example below, we also added the -w operator to show whole words, but the output form is the same.

Inverse grep Search

You can use grep to print all lines that do not match a specific pattern of characters. To invert the search, append -v to a grep command.

To exclude all lines that contain phoenix, enter:

grep -v phoenix sample

The terminal prints all lines that do not contain the word used as a search criterion. Use -i to ignore case to exclude completely the word used for this search:

To Show Lines That Exactly Match a Search String

The grep command prints entire lines when it finds a match in a file. To print only those lines that completely match the search string, add the -x option.

grep -x “phoenix number3” *

The output shows only the lines with the exact match. If there are any other words or characters in the same line, the grep does not include it in the search results. Do not forget to use quotation marks whenever there is a space or a symbol in a search pattern.

Here is a comparison of the results without and with the -x operator in our grep command:

To List Names of Matching Files

Sometimes, you only need to see the names of the files that contain a word or string of characters and exclude the actual lines. To print only the filenames that match your search, use the -l operator:

grep -l phoenix *

The output shows the exact filenames that contain phoenix in the current directory but does not print the lines with the corresponding word:

As a reminder, use the recursive search operator -r to include all subdirectories in your search.

To Count the Number of Matches

Grep can display the filenames and the count of lines where it finds a match for your word.

Use the -c operator to count the number of matches:

grep -c phoenix *

To Display the Number of Lines Before or After a Search String

Sometimes you need more content in search results to decide what is most relevant.

Use the following operators to add the desired lines before, after a match, or both:

• Use -A and a number of lines to display after a match: grep -A 3 phoenix sample — this command prints three lines after the match.
• Use -B and a number of lines to display before a match: grep -B 2 phoenix sample — this command prints two lines before the match.
• Use -C and a number of lines to display before and after the match: grep -C 2 phoenix sample — this command prints two lines before and after the match.

To Display Line Numbers with grep Matches

When grep prints results with many matches, it comes handy to see the line numbers. Append the -n operator to any grep command to show the line numbers.

We will search for Phoenix in the current directory, show two lines before and after the matches along with their line numbers.

grep -n -C 2 Phoenix sample

Limit grep Output to a Fixed Number of Lines

Individual files, such as log files, can contain many matches for grep search patterns. Limit the number of lines in the grep output by adding the -m option and a number to the command.

grep -m2 Phoenix sample

In this case, the terminal prints the first two matches it finds in the sample file.

If you do not specify a file and search all files in a directory, the output prints the first two results from every file along with the filename that contains the matches.

Conclusion

Now you know how to use the grep command in Linux/Unix.

The grep command is highly flexible with many useful operators and options. By combining grep commands, you can get powerful results and find the text hiding in thousands of files. To get started, check out our grep regex guide article.

By default, most search tools look at file names, not file contents. However, the most famous GNU search program, grep, will look inside files with the correct flags. Here we show you how you can find specific word(s) in a file on Linux.

By default, grep searches through the contents of files as well as their file names. It’s included on the majority of Linux systems and is generally identical across distros. Programmers looking through the file contents of their projects might prefer to run a different command, like ack.

Depending on how the file is encoded, grep may not always be able to look inside. But for most text-based formats, grep can scan the text of the file for the specified pattern.

grep -rw '/path/to/search/' -e 'pattern'

• The -r flag sets grep to recursive mode, navigating through all the directories contained within the specified directory.
• The -w flag searches for whole word matches. This means that “red” will match only the actual word “red” rather than any string of letters containing it, like “redundant” or “tired.” It does this by looking only for “red” surrounded by what is known as non-word constituent characters (i.e., anything that isn’t a letter, number or underscore).
• The -e flag prefaces the pattern to search for. It supports regular expressions by default.

To speed up grep, you can use the --exclude and --include flags to limit the search to certain types of files. For example, --exclude='*.csv' will not search within any files with the .csv extension. --include='*.txt', on the other hand, will only search within files with the .txt extension. The flag can be added immediately after the grep command as shown below:

grep --exclude='*.csv' -Rw '/path/to/search' -e 'pattern'

You can also exclude specified directories by following the format below:

grep --exclude-dir='{dir1,dir2,*_old}' -Rw '/path/to/search' -e 'pattern'

This command will not search in any directories in the present working directory named dir1, dir2, or matching the pattern *_old, eliminating them from the search process. It will execute the specified recursive, full-word match search on all other files in the present working directory.

Interesting Flags You Can Use With grep

Now that you have been properly acquainted with grep and how it works, here are some useful flags you can attach to your command:

• -i – Makes grep do a non-case-sensitive search. For example, searching for “Kraken” will return a result when grep finds matches for “kraken” or “kRaken”.
• -n – Show line numbers next to matches. This is especially useful for programmers or people looking through large config files.
• -R – As with -r, grep will do a recursive search through all subfolders, but this specific flag will follow symbolic links (shortcuts).
• -s – Suppresses error messages. If you’re getting many distracting errors about files that don’t exist, can’t be read, or have inappropriate permissions, pass this so that grep can stick to showing you matches it finds.

Using find to Find a Specific Word in a File

While the find command’s syntax is more complicated than grep, some prefer it.

find . -name "*.php" -exec grep "pattern" {} ;

This command will use find’s -exec flag to pass the found files to grep for searching. With a clever arrangement of syntax, you can use find‘s faster file-system search to locate the specific file types you want to search within, then pipe them to grep to search inside the files.

Note that find only looks at filenames, not contents. That’s why grep is required to search file text and contents. The normal grep flags should be fully operational from within the -exec flag.

Using ack to Find a Specific Word in a File

The ack command is likely the fastest searching tool, but it’s not as popular as grep. The command below will search within the current directory.

If you want to search within a specific file or directory, you can append that file or fully-qualified pathname to your search.

ack 'pattern' /path/to/file.txt

Want a GUI? Use Catfish

If you’re allergic to terminals, all the popular Linux distros offer Catfish, a versatile GUI application that allows you to search files and their contents for a specific string. It isn’t as advanced as the commands discussed here, but it provides a valuable service to people who would prefer a graphical interface.

To search file contents for a specific word, click the menu on the top-right corner of Catfish and click on “Search file contents.”

After you’ve set it up, type what you want to search for in the top bar and press Enter. That’s it!

Frequently Asked Questions

All screenshots by Miguel Leiva-Gomez.

grep (GNU or BSD)

You can use grep tool to search recursively the current folder, like:

grep -r "class foo" .

^{Note: -r — Recursively search subdirectories.}

You can also use globbing syntax to search within specific files such as:

grep "class foo" **/*.c

^{Note: By using globbing option (**), it scans all the files recursively with specific extension or pattern. To enable this syntax, run: shopt -s globstar. You may also use **/*.* for all files (excluding hidden and without extension) or any other pattern.}

If you’ve the error that your argument is too long, consider narrowing down your search, or use find syntax instead such as:

find . -name "*.php" -execdir grep -nH --color=auto foo {} ';'

Alternatively, use ripgrep.

ripgrep

If you’re working on larger projects or big files, you should use ripgrep instead, like:

rg "class foo" .

^{Checkout the docs, installation steps or source code on the GitHub project page.}

It’s much quicker than any other tool like GNU/BSD grep, ucg, ag, sift, ack, pt or similar, since it is built on top of Rust’s regex engine which uses finite automata, SIMD and aggressive literal optimizations to make searching very fast.

It supports ignore patterns specified in .gitignore files, so a single file path can be matched against multiple glob patterns simultaneously.

You can use common parameters such as:

• -i — Insensitive searching.
• -I — Ignore the binary files.
• -w — Search for the whole words (in the opposite of partial word matching).
• -n — Show the line of your match.
• -C/--context (e.g. -C5) — Increases context, so you see the surrounding code.
• --color=auto — Mark up the matching text.
• -H — Displays filename where the text is found.
• -c — Displays count of matching lines. Can be combined with -H.

Do you want to find all files that contain a particular word or string of text on your entire Linux system or a given directory. This article will guide you on how to do that, you will learn how to recursively dig through directories to find and list all files that contain a given string of text.

A simple way to work this out is by using grep pattern searching tool, is a powerful, efficient, reliable and most popular command-line utility for finding patterns and words from files or directories on Unix-like systems.

Read Also: 11 Advanced Linux ‘Grep’ Commands on Character Classes and Bracket Expressions

The command below will list all files containing a line with the text “check_root”, by recursively and aggressively searching the ~/bin directory.

$ grep -Rw ~/bin/ -e 'check_root'

Where the -R option tells grep to read all files under each directory, recursively, following symbolic links only if they are on the command line and option -w instructs it to select only those lines containing matches that form whole words, and -e is used to specify the string (pattern) to be searched.

You should use the sudo command when searching certain directories or files that require root permissions (unless you are managing your system with the root account).

 
$ sudo grep -Rw / -e 'check_root'	

To ignore case distinctions employ the -i option as shown:

$ grep -Riw ~/bin/ -e 'check_root'

If you want to know the exact line where the string of text exist, include the -n option.

$ grep -Rinw ~/bin/ -e 'check_root'

Assuming there are several types of files in a directory you wish to search in, you can also specify the type of files to be searched for instance, by their extension using the --include option.

This example instructs grep to only look through all .sh files.

$ grep -Rnw --include=*.sh ~/bin/ -e 'check_root'

In addition, it is possible to search for more than one pattern, using the following command.

$ grep -Rinw ~/bin/ -e 'check_root' -e 'netstat'

That’s It! If you know any other command-line trick to find string or word in files, do share with us or ask any questions regarding this topic, use the comment form below.

If You Appreciate What We Do Here On TecMint, You Should Consider:

TecMint is the fastest growing and most trusted community site for any kind of Linux Articles, Guides and Books on the web. Millions of people visit TecMint! to search or browse the thousands of published articles available FREELY to all.

If you like what you are reading, please consider buying us a coffee ( or 2 ) as a token of appreciation.

We are thankful for your never ending support.