How to List Files Recursively in Linux

Listing files recursively in Linux is a common task that helps you explore directories and their contents deeply. Whether you want to see all files inside a folder and its subfolders or filter specific file types, knowing how to list files recursively can save you time and effort. In this article, I’ll guide you through the most effective ways to do this using popular Linux commands.

You’ll learn simple commands like ls and find, as well as more visual tools like tree. By the end, you’ll feel confident navigating your Linux file system and listing files exactly how you want. Let’s dive into the practical steps and examples that make recursive file listing easy.

Understanding Recursive File Listing in Linux

Recursive file listing means showing all files and directories inside a specified folder, including everything in its subdirectories. This is different from a simple file list that only shows the current directory’s contents.

When you list files recursively, you get a complete view of the folder structure. This is useful for:

• Checking all files in a project folder
• Searching for specific files deep inside directories
• Managing backups or cleaning up files

Linux offers several commands to list files recursively, each with different options and output styles. Knowing which command to use depends on your needs.

Using the ls Command to List Files Recursively

The ls command is one of the most basic and widely used commands to list files in Linux. To list files recursively, you can use the -R option.

How to Use ls -R

ls -R /path/to/directory

This command lists all files and directories inside the specified path, including all subdirectories.

What You Get with ls -R

• Directory names followed by their contents
• Files listed under each directory
• A simple text output that shows the folder hierarchy

Example

ls -R ~/Documents

This will display all files and folders inside your Documents directory and all its subfolders.

Limitations of ls -R

• Output can be long and hard to read for large directories
• No filtering options for file types or sizes
• Does not show file sizes or permissions by default (you can add -l for detailed info)

Using the find Command for More Powerful Recursive Listing

The find command is a powerful tool for searching and listing files recursively with many filtering options.

Basic Recursive Listing with find

find /path/to/directory

This lists all files and directories inside the given path recursively.

Filtering Files with find

You can filter files by name, type, size, modification time, and more. For example:

• List only files (not directories):

  find /path/to/directory -type f
  

• List files with a specific extension, like .txt:

  find /path/to/directory -type f -name "*.txt"
  

• List files modified in the last 7 days:

  find /path/to/directory -type f -mtime -7
  

Advantages of find

• Highly customizable with many options
• Can execute commands on found files (e.g., delete, move)
• Works well with large directory trees

Example: List All .jpg Files Recursively

find ~/Pictures -type f -name "*.jpg"

This command lists all JPEG images inside the Pictures folder and its subfolders.

Using the tree Command for Visual Recursive Listing

The tree command shows a directory structure in a tree-like format, which is easier to read visually.

Installing tree

If tree is not installed, you can install it using:

• On Debian/Ubuntu:

  sudo apt install tree
  

• On Fedora:

  sudo dnf install tree
  

• On Arch Linux:

  sudo pacman -S tree
  

Basic Usage of tree

tree /path/to/directory

This displays the directory and all its contents recursively in a tree format.

Useful Options with tree

• Show only files (no directories):

  tree -f -i /path/to/directory
  

• Limit the depth of recursion (e.g., 2 levels):

  tree -L 2 /path/to/directory
  

• Show file sizes:

  tree -h /path/to/directory
  

Example

tree -L 3 -h ~/Projects

This shows the Projects directory up to 3 levels deep, including file sizes.

Comparing ls, find, and tree for Recursive Listing

Choosing the right command depends on what you want:

• Use ls -R for a quick look at all files.
• Use find when you need to filter or search files.
• Use tree for a clear visual overview.

Tips for Efficient Recursive File Listing

When working with recursive file listings, keep these tips in mind:

• Use output redirection to save results to a file:

  find /path/to/directory > filelist.txt
  

• Combine commands with grep to filter results further:

  find /path/to/directory | grep "report"
  

• Use xargs with find to perform actions on files:

  find /path/to/directory -type f -name "*.log" | xargs rm
  

• Limit recursion depth to avoid overwhelming output:

  find /path/to/directory -maxdepth 2
  

• Use tree with color output for better readability:

  tree -C /path/to/directory
  

Handling Permissions and Hidden Files

Sometimes, you might encounter permission errors or want to include hidden files (those starting with a dot).

• To list hidden files with ls:

  ls -aR /path/to/directory
  

• To include hidden files with find:

  find /path/to/directory -name ".*"
  

• Run commands with sudo if you need permission to access certain directories:

  sudo find /root -type f
  

Be cautious when using sudo to avoid accidental changes to system files.

Conclusion

Now you know how to list files recursively in Linux using different commands. The ls -R command is great for simple listings, while find offers powerful filtering and searching capabilities. For a clear visual structure, tree is your best choice.

By mastering these commands, you can easily explore your Linux file system, find files quickly, and manage directories efficiently. Try these commands yourself and see how they can simplify your workflow.

FAQs

How do I list all files including hidden ones recursively?

Use ls -aR /path/to/directory or find /path/to/directory -name ".*" to include hidden files in your recursive listing.

Can I limit the depth of recursion when listing files?

Yes, with find use -maxdepth (e.g., find /path -maxdepth 2), and with tree use -L (e.g., tree -L 2).

How do I list only files, not directories?

Use find /path -type f to list only files recursively, excluding directories.

Is there a way to save the recursive file list to a file?

Yes, redirect the output to a file like this: find /path > filelist.txt.

What command shows a visual tree of files and folders?

The tree command displays a visual directory tree with files and folders recursively.