Home Linux Commands Mastering find command in Linux with examples

Mastering find command in Linux with examples

Dive into the world of Linux command-line tools with this practical guide to the find command, tailored for Raspberry Pi users. Learn how to efficiently search for files and directories, apply advanced filters, and automate tasks with real-world examples.

by Kiran Kumar
find command linux

Navigating the vast expanse of files and directories in Linux can be a daunting task, akin to finding a needle in a digital haystack. As a Linux enthusiast, I’ve spent several hours on my Raspberry Pi, exploring and tinkering with various commands. Among these, the find command stands out as an indispensable tool in my Linux toolkit.

In this blog, we’ll dive deep into the find command, exploring its nuances through practical examples on a Raspberry Pi. Whether you’re a seasoned pro or a curious novice, this guide aims to enhance your command-line prowess.

Understanding the find command

At its core, the find command in Linux is your digital Sherlock Holmes, adept at searching through the intricate file system to locate files and directories based on your specified criteria. From file names and types to modification dates, find can unearth files meeting a wide array of conditions.

Finding files by name

One of the most common uses of the find command is locating files by their names. This is particularly useful when you know the name of the file but are unsure of its location. Here’s a simple command to find a file named example.txt:

find / -name example.txt

In this command, / specifies the root directory as the starting point for the search, ensuring a thorough scan of your entire file system. The -name option is case-sensitive, which means it will only find files that match the exact case of the specified name. If you’re unsure about the case, you can use -iname for a case-insensitive search, making it a bit more user-friendly but potentially slower due to the broader search scope.

Sample Output:


In this output, the find command discovered two instances of example.txt, one in the Documents directory of the user pi and another on a mounted USB drive. The search began from the root directory /, encompassing the entire filesystem.

Searching for files by type

Another aspect I appreciate about the find command is its ability to filter searches by file type. This feature is incredibly useful when you’re looking for directories, symbolic links, or special files. For example, to find all directories named projects:

find / -type d -name projects

Here, -type d instructs find to look exclusively for directories. This specificity significantly narrows down the search, making it faster and more relevant.

Sample Output:


This output shows that the command found two directories named projects, one in the pi user’s home directory and another within the web server’s root directory. The -type d option ensured that only directories were listed.

Finding files by modification time

As someone who constantly tinkers with files, I often need to locate files modified within a specific time frame. The find command excels here as well. For instance, to find files in the home directory that were modified in the last 7 days:

find /home -mtime -7

The -mtime -7 option is a godsend, allowing me to zero in on recently modified files, with -mtime specifying the modification time and -7 meaning “less than 7 days ago.”

Sample Output:


Here, the command lists files under /home modified in the last 7 days. The output includes a mix of documents, images, and even the user’s bash history file, demonstrating the command’s ability to catch a wide variety of recently altered files.

Executing commands on found files

Perhaps the most powerful feature of the find command is its ability to execute commands on the files it finds. This capability is a game-changer for batch processing. For example, to find all .jpg files and move them to a backup directory:

find / -type f -name '*.jpg' -exec mv {} /backup/ \;

The -exec option followed by mv {} /backup/ \; is where the magic happens. {} serves as a placeholder for each file found, and \; marks the end of the command. This pattern is incredibly versatile, allowing for a wide range of operations on the search results.

Sample Output:

No direct output is shown after executing this command since the -exec action performs the move operation silently. However, if you were to check the /backup/ directory afterwards, you would find it populated with .jpg files found across the filesystem, such as:


This output in the /backup/ directory confirms the successful execution of the find command with -exec, moving all .jpg files to the specified directory.

Tips and tricks

  • Use the -maxdepth option to limit the depth of directories find will search, speeding up the search and reducing the load on your Raspberry Pi.
  • Combine find with other commands like grep for more refined searches. For instance, find . -type f | grep -i 'pattern' can be used to find files containing a specific pattern, case-insensitively.

Command (combining find with grep):

find . -type f | grep -i 'pattern'

Sample Output:


This combination effectively narrows down the search to files containing the word “pattern” in their path or name, showcasing the flexibility of find when used alongside other utilities.

Find command in Linux cheat sheet

This table provides a handy reference for some of the most useful find command options, aiding in crafting precise and efficient file searches in the Linux environment.

Option Description
-name 'pattern' Search for files that match the given pattern (case-sensitive).
-iname 'pattern' Search for files with a case-insensitive match to the given pattern.
-type f Look for regular files.
-type d Search for directories.
-mtime n Find files modified n*24 hours ago. For example, -mtime 1 finds files modified in the last 24 to 48 hours.
-mtime +n Find files modified more than n days ago.
-mtime -n Find files modified less than n days ago.
-size n Find files of a specific size. n can be specified in blocks (default), kilobytes (k), megabytes (M), gigabytes (G), etc.
-exec cmd {} \; Execute a command cmd on each found file, replacing {} with the current file name.
-delete Delete the found files (use with caution).
-perm mode Search for files with specific permissions. mode can be symbolic (like u=rwx) or numeric (like 644).
-user name Find files owned by the user named name.
-group name Find files belonging to the group named name.
-maxdepth n Descend at most n directory levels below the command line arguments.
-mindepth n Do not apply tests or actions at levels less than n.

My two cents on the find command in Linux

Throughout my adventures with my Raspberry Pi, the find command has been an irreplaceable ally. Its versatility and depth never cease to amaze me, though I must admit, its syntax can sometimes be intimidating. Yet, the satisfaction of crafting the perfect find command to efficiently locate exactly what I need is unmatched. My personal favorite is using find with -exec, as it feels like orchestrating a symphony of commands that spring into action, each playing its part in perfect harmony.

FAQ: Mastering the Find command in Linux

How do I find files containing specific text?

To find files containing specific text, combine find with grep. For example, to find files containing “Hello World” in the current directory and subdirectories:

find . -type f -exec grep -l "Hello World" {} +

This command searches for files (-type f) and uses grep -l to list those containing “Hello World”.

Can I use find to search for multiple file types at once?

Yes, you can search for multiple file types by combining multiple -type options with -o (logical OR). For example, to find both directories and symbolic links:

find . \( -type d -o -type l \)

This command looks for items that are either directories (d) or symbolic links (l).

How do I limit the depth of a find search?

Use the -maxdepth option to limit the depth. For instance, to search only in the current directory (depth of 1):

find . -maxdepth 1 -name 'example.txt'

This command searches for example.txt only in the current directory, without delving into subdirectories.

How can I find files by permissions?

Use the -perm option. For example, to find files with permissions set to 644:

find . -type f -perm 644

This command finds regular files (-type f) with permissions exactly matching 644.

How do I exclude a directory from the search?

Use the -path option with -prune. For example, to exclude the node_modules directory:

find . -path ./node_modules -prune -o -name '*.js' -print

This tells find to ignore node_modules and its contents, looking for .js files elsewhere.

Can find command handle filenames with spaces?

Yes, find can handle filenames with spaces. When using -exec, {} handles spaces properly. For example:

find . -type f -name "*.txt" -exec cp {} /backup/ \;

This copies .txt files, even with spaces in their names, to /backup/.

How do I find and remove files safely?

Use find with -delete, but always double-check your command to avoid accidental deletion. For example, to delete .tmp files:

find . -type f -name '*.tmp' -delete

Always run the command without -delete first to see what gets matched.

Can I find files based on their modification time?

Absolutely. Use -mtime for modification time. For instance, to find files modified more than 7 days ago:

find . -type f -mtime +7

This lists files last modified over 7 days ago.

Is it possible to find empty files and directories?

Yes, use -empty to find empty files and directories:

find . -empty

This command lists all empty files and directories in the current directory and subdirectories.

How do I handle special characters in filenames?

To handle special characters, such as asterisks or question marks, escape them or use quotation marks. For example, to find files with a question mark in the name:

find . -name '*\?*'

This escapes the question mark to treat it as a literal character in the search pattern.


In the vast digital landscape of Linux, equipped with the find command, you’re never truly lost. Whether you’re sifting through the depths of your file system on a Raspberry Pi or any other Linux system, find offers a beacon of hope, lighting the way to your sought-after files and directories. With the examples and insights shared in this guide, I hope to empower you to harness the full potential of find, turning your file searching tasks from daunting chores into rewarding quests.

You may also like

Leave a Comment

* By using this form you agree with the storage and handling of your data by this website.