Counting Files in a Linux Directory with Examples: 4 Easy Steps

This guide will teach you how to Counting Files in a Linux Directory with Examples. You can easily leverage Linux Commands to count the files within a directory. We’ll demonstrate the use of ls, find, rsync, and tree commands to achieve this. To illustrate the steps involved in Counting Files in a Linux Directory with Examples, we’ll create a sample directory with files and then show you how to count them.

To follow this guide for Counting Files in a Linux Directory with Examples, you’ll need access to a Linux server, either as a root user or a non-root user with sudo privileges. You can find initial server setup guides on various hosting provider websites.

Let’s begin by creating a directory and some files. Execute the following commands:

# mkdir test_dir
# cd test_dir
# mkdir first_subdir second_subdir
# touch file1.py file2.js file3.c

Next, navigate to the first subdirectory and create files there:

# cd first_subdir
# touch file4.txt file5.txt file6.txt

And similarly, for the second subdirectory:

# cd ..
# cd second_subdir
# mkdir third_subdir
# touch file7.txt

Now, return to your "test_dir" directory and follow the steps below to learn how to count files and directories in Linux.

cd ..

Step 1 – Use the ls command for Counting Files and Directories

The ls command is a fundamental tool for Counting Files in a Linux Directory with Examples.

To count files in the current directory, execute the following ls command:

ls | wc -l

**Output**
5

To count files within a specific directory, use:

ls <directory name or full path> | wc -l

For instance, to count the files in our "first_subdir":

ls first_subdir | wc -l

**Output**
3

The ls command can also be used to display only files. We can go back to the home directory and count the files in the "test_dir" with the following command:

# cd ..
# ls -1Up test_dir | grep -v / | wc -l

**Output**
3

The options used in this command mean:

• -1: Lists one entry per line.
• -U: Lists entries in directory order.
• -p: Appends a slash (/) to directory names.
• grep -v /: Excludes lines ending with a slash (directories).
• wc -l: Counts the lines.

Step 2 – Use the find command for Counting Linux Files and Directories

Another powerful command for Counting Files in a Linux Directory with Examples is the find command.

To count all files and directories within a specific directory, use the following command:

find <directory> | wc -l

For example, to count files and directories in the "test_dir":

find test_dir | wc -l

**Output**
11

To count only files in the directory, use:

find test_dir -type f | wc -l

**Output**
7

Step 3 – Use the rsync command to List and Count Files and Directories

For Counting Files in a Linux Directory with Examples, you can use the rsync command to display file and directory information. Let’s apply it to our "test_dir":

rsync --stats --dry-run -a test_dir

The output will resemble:

**Output**
drwxr-xr-x          4,096 2023/09/11 06:25:28 test_dir
-rw-r--r--              0 2023/09/11 06:25:28 test_dir/file1.py
-rw-r--r--              0 2023/09/11 06:25:28 test_dir/file2.js
-rw-r--r--              0 2023/09/11 06:25:28 test_dir/file3.c
drwxr-xr-x          4,096 2023/09/11 06:25:38 test_dir/first_subdir
-rw-r--r--              0 2023/09/11 06:25:38 test_dir/first_subdir/file4.txt
-rw-r--r--              0 2023/09/11 06:25:38 test_dir/first_subdir/file5.txt
-rw-r--r--              0 2023/09/11 06:25:38 test_dir/first_subdir/file6.txt
drwxr-xr-x          4,096 2023/09/11 06:25:59 test_dir/second_subdir
-rw-r--r--              0 2023/09/11 06:25:59 test_dir/second_subdir/file7.txt
drwxr-xr-x          4,096 2023/09/11 06:25:54 test_dir/second_subdir/third_subdir

**Number of files: 11 (reg: 7, dir: 4)
**Number of created files: 0
Number of deleted files: 0
Number of regular files transferred: 0
Total file size: 0 bytes
Total transferred file size: 0 bytes
Literal data: 0 bytes
Matched data: 0 bytes
File list size: 0
File list generation time: 0.001 seconds
File list transfer time: 0.000 seconds
Total bytes sent: 352
Total bytes received: 838

sent 352 bytes  received 838 bytes  2,380.00 bytes/sec
total size is 0  speedup is 0.00 (DRY RUN)

This command provides a detailed overview of your directory and its files.

Step 4 – View the Linux Directory Structure with the tree command

The tree command is another useful tool that visualizes the directory structure and counts the files.

To view the structure of the "test_dir", execute:

tree test_dir

(The original article’s screenshot of the tree command’s output would be displayed here.)

The -a option can be added to show hidden files:

tree -a test_dir

That concludes our guide on Counting Files in a Linux Directory with Examples.

Conclusion

You’ve now learned how to use various Linux commands for Counting Files in a Linux Directory with Examples, including ls, find, rsync, and tree. We hope you found this helpful!

Do you have any suggestions? Please leave a comment below.

You might also find these articles interesting:

• File permissions in Linux with examples
• Environment Variables in Linux
• How To Force User To Logout in Linux

Alternative Solutions for Counting Files

While the previous methods are effective, here are two alternative approaches for counting files in a Linux directory.

Alternative 1: Using stat and awk

This method leverages the stat command to retrieve file information and awk to process the output and count the files. The advantage of this method is that it’s often faster than find for large directories, as it avoids traversing the entire directory structure.

Explanation:

1. stat -c "%n": This part uses the stat command with the -c option to specify a format string. The %n format specifier tells stat to output only the name of each file.
2. test_dir/*: This expands to all files and directories directly within the test_dir directory (but not subdirectories).
3. awk 'BEGIN { count=0 } !/directory/ { count++ } END { print count }': This awk script does the following:
   • BEGIN { count=0 }: Initializes a counter variable named count to 0 before processing any input.
   • !/directory/ { count++ }: For each line of input (i.e., each filename), this checks if the line contains the string "directory". If it doesn’t contain "directory" (meaning it’s a file), the count variable is incremented. This assumes that directories have "directory" somewhere in their stat output, which is generally true.
   • END { print count }: After processing all lines, this prints the final value of the count variable.

Code Example:

stat -c "%n" test_dir/* | awk 'BEGIN { count=0 } !/directory/ { count++ } END { print count }'

This will output the number of files directly within the test_dir directory, excluding subdirectories. To make it recursive, you’d need to combine it with a loop or other mechanisms, which would then become similar to using find.

Alternative 2: Using a Bash Loop and Conditional

This approach utilizes a bash loop to iterate through the directory contents and a conditional statement to check if each item is a file. This is a pure bash solution, avoiding external commands like find.

Explanation:

1. count=0: Initializes a variable named count to 0. This will store the number of files.
2. for item in "test_dir/*"; do ... done: This loop iterates over all items (files and directories) within the test_dir directory. The quotes are important to handle filenames with spaces.
3. if [ -f "$item" ]; then ... fi: This conditional statement checks if the current item ($item) is a regular file. The -f option is a bash test operator that returns true if the file exists and is a regular file (not a directory, symbolic link, etc.).
4. ((count++)): If the item is a file, this increments the count variable by 1. ((...)) is used for arithmetic evaluation in bash.
5. echo "$count": After the loop finishes, this prints the final value of the count variable, which represents the total number of files in the directory.

Code Example:

count=0
for item in "test_dir/*"; do
  if [ -f "$item" ]; then
    ((count++))
  fi
done
echo "$count"

Like the stat and awk solution, this only counts files directly within test_dir and not recursively. To count files recursively with this method, you’d need to implement a recursive function in bash, which can become complex. While potentially educational, it’s generally less efficient than using find for recursive file counting.