Understanding the rm Command in Linux: Removing Files and Directories

$ rm [OPTION]... FILE...

# Create a test directory named rm_test_area for rm command examples.
$ mkdir rm_test_area
 
# Change the current working directory to rm_test_area.
$ cd rm_test_area
 
# Create a file named file1.txt with the content "Content for file1".
$ echo "Content for file1" > file1.txt
 
# Create a file named file2.log with the content "Content for file2".
$ echo "Content for file2" > file2.log
 
# Create an empty file named temporary_file.tmp.
$ touch temporary_file.tmp
 
# Create an empty hidden file named .hidden_file (hidden due to the leading dot).
$ touch .hidden_file
 
# Create a directory named docs within rm_test_area.
$ mkdir docs
 
# Create a file named documentA.pdf inside the docs directory with the content "Doc A".
$ echo "Doc A" > docs/documentA.pdf
 
# Create a subdirectory named archive inside the docs directory.
$ mkdir docs/archive
 
# Create a file named old_document.txt inside docs/archive with the content "Old doc".
$ echo "Old doc" > docs/archive/old_document.txt
 
# Create a file named protected_file.txt with the content "Protected content".
$ echo "Protected content" > protected_file.txt
 
# Set read-only permissions (444) on protected_file.txt to make it write-protected.
$ chmod 444 protected_file.txt

# List all files and directories, including hidden ones, with detailed information to verify the setup.
$ ls -lA
total 16
drwxr-xr-x 3 user user 4096 May 12 16:39 docs
-rw-r--r-- 1 user user   18 May 12 16:39 file1.txt
-rw-r--r-- 1 user user   18 May 12 16:39 file2.log
-r--r--r-- 1 user user   18 May 12 16:39 protected_file.txt
-rw-r--r-- 1 user user    0 May 12 16:39 temporary_file.tmp
-rw-r--r-- 1 user user    0 May 12 16:39 .hidden_file

# Remove a single file named temporary_file.tmp from the current directory.
$ rm temporary_file.tmp

$ ls -A
docs  file1.txt  file2.log  protected_file.txt  .hidden_file

# Remove multiple files, file1.txt and file2.log, in a single command.
$ rm file1.txt file2.log

$ ls -A
docs  protected_file.txt  .hidden_file

# Create sample log files named app1.log and app2.log, and a text file named system.txt for demonstration.
$ touch app1.log app2.log system.txt
 
# Use a wildcard to delete all files with the .log extension in the current directory.
$ rm *.log

$ ls -A
docs  protected_file.txt  system.txt  .hidden_file

# Recursively delete the docs directory and all its contents, including subdirectories and files.
$ rm -r docs

$ ls -A
protected_file.txt  system.txt  .hidden_file

# Create an empty directory named empty_dir for demonstration.
$ mkdir empty_dir
 
# Remove the empty directory named empty_dir using the -d option.
$ rm -d empty_dir

$ ls -d empty_dir
ls: cannot access 'empty_dir': No such file or directory

# Attempt to remove a write-protected file named protected_file.txt, which prompts for confirmation.
$ rm protected_file.txt

rm: remove write-protected regular file 'protected_file.txt'? y

# Remove the hidden file named .hidden_file from the current directory.
$ rm .hidden_file

$ ls -A
system.txt

# Create sample files named data1.csv and data2.csv for demonstration.
$ touch data1.csv data2.csv
 
# Use the -i option to prompt for confirmation before deleting each file.
$ rm -i data1.csv data2.csv

rm: remove regular file 'data1.csv'? y
rm: remove regular file 'data2.csv'? n

# Create a file named readonly.txt for demonstration.
$ touch readonly.txt
 
# Set read-only permissions (444) on readonly.txt to make it write-protected.
$ chmod 444 readonly.txt
 
# Use the -f option to force deletion of readonly.txt and ignore nonexistent.txt without prompting.
$ rm -f readonly.txt nonexistent.txt

$ ls readonly.txt nonexistent.txt
ls: cannot access 'readonly.txt': No such file or directory
ls: cannot access 'nonexistent.txt': No such file or directory

# Create a directory named project with a subdirectory src, and a directory named tests.
$ mkdir -p project/src tests
 
# Create a file named main.c inside project/src.
$ touch project/src/main.c
 
# Create a file named test1.py inside tests.
$ touch tests/test1.py
 
# Recursively delete the project directory and its contents.
$ rm -r project

$ ls project
ls: cannot access 'project': No such file or directory

# Create an empty directory named empty_folder.
$ mkdir empty_folder
 
# Create a directory named non_empty_folder.
$ mkdir non_empty_folder
 
# Create a file named file.txt inside non_empty_folder to make it non-empty.
$ touch non_empty_folder/file.txt
 
# Attempt to remove both directories using -d; only empty_folder will be removed.
$ rm -d empty_folder non_empty_folder

rm: cannot remove 'non_empty_folder': Directory not empty
$ ls empty_folder
ls: cannot access 'empty_folder': No such file or directory

# Create sample files named log1.txt and log2.txt for demonstration.
$ touch log1.txt log2.txt
 
# Use the -v option to see verbose output while deleting the files.
$ rm -v log1.txt log2.txt

removed 'log1.txt'
removed 'log2.txt'

# Create a directory named data with a subdirectory mnt (simulating a mount point).
$ mkdir -p data/mnt
 
# Create a file named local_file.txt inside data.
$ touch data/local_file.txt
 
# Create a file named external_file.txt inside data/mnt.
$ touch data/mnt/external_file.txt
 
# Recursively delete the data directory but skip any mounted filesystems within it using --one-file-system.
$ rm -r --one-file-system data

$ ls data/mnt
external_file.txt

# Display the help information for the rm command, summarizing its options and usage.
$ rm --help

Usage: rm [OPTION]... [FILE]...
Remove (unlink) the FILE(s).
 
  -f, --force           ignore nonexistent files and arguments, never prompt
  -i                    prompt before every removal
  -r, -R, --recursive   remove directories and their contents recursively
  -d, --dir             remove empty directories
  -v, --verbose         explain what is being done
      --help     display this help and exit
      --version  output version information and exit

# Display the version information of the rm command to verify its installation and version.
$ rm --version

rm (GNU coreutils) 8.32
Copyright (C) 2020 Free Software Foundation, Inc.

# Create a directory named backups with subdirectories 2023 and 2024 (note: 2024 is created but not nested due to space-separated arguments).
$ mkdir -p backups/2023 2024
 
# Create a file named jan.txt inside backups/2023.
$ touch backups/2023/jan.txt
 
# Create a file named feb.txt inside 2024.
$ touch backups/2024/feb.txt
 
# Combine -r and -i options to recursively delete the backups directory with prompts for confirmation.
$ rm -ri backups

rm: descend into directory 'backups'? y
rm: descend into directory 'backups/2023'? y
rm: remove regular file 'backups/2023/jan.txt'? y
rm: remove directory 'backups/2023'? y
rm: descend into directory 'backups/2024'? n
rm: remove directory 'backups'? n

# Create a directory named logs.
$ mkdir -p logs
 
# Create a file named error.log inside logs.
$ touch logs/error.log
 
# Set read-only permissions recursively on the logs directory and its contents.
$ chmod -R 444 logs
 
# Use -rf to force recursive deletion of the logs directory and its contents without prompts.
$ rm -rf logs

$ ls logs
ls: cannot access 'logs': No such file or directory

# Create a directory named cache with a subdirectory tmp.
$ mkdir -p cache/tmp
 
# Create a file named session1.dat inside cache/tmp.
$ touch cache/tmp/session1.dat
 
# Use -rv to see verbose output while recursively deleting the cache directory.
$ rm -rv cache

removed 'cache/tmp/session1.dat'
removed directory 'cache/tmp'
removed directory 'cache'

# Create a file named -file.txt using -- to prevent misinterpretation of the hyphen as an option.
$ touch -- -file.txt
 
# Use -- to remove the file named -file.txt, ensuring the hyphen is treated as part of the filename.
$ rm -- -file.txt

$ ls -file.txt
ls: cannot access '-file.txt': No such file or directory

# Create a file named "My File!.txt" with spaces and special characters.
$ touch "My File!.txt"
 
# Remove the file named "My File!.txt" using quotes to handle spaces and special characters.
$ rm "My File!.txt"

$ ls "My File!.txt"
ls: cannot access 'My File!.txt': No such file or directory

# Create a directory named restricted.
$ mkdir restricted
 
# Create a file named file.txt inside restricted.
$ touch restricted/file.txt
 
# Set read and execute permissions (555) on restricted, removing write permission.
$ chmod 555 restricted
 
# Attempt to remove the file restricted/file.txt; this will fail due to lack of write permission on the directory.
$ rm restricted/file.txt

rm: cannot remove 'restricted/file.txt': Permission denied

# Create a target file named target.txt.
$ touch target.txt
 
# Create a symbolic link named link.txt pointing to target.txt.
$ ln -s target.txt link.txt
 
# Remove the symbolic link named link.txt.
$ rm link.txt

$ ls target.txt
target.txt

# Create a directory named folder.
$ mkdir folder
 
# Attempt to remove the directory named folder without -r; this will fail.
$ rm folder

rm: cannot remove 'folder': Is a directory

# Attempt to remove a file named file.txt in the mounted directory /mnt/test; this may fail if the mount is busy.
$ rm /mnt/test/file.txt

rm: cannot remove '/mnt/test/file.txt': Device or resource busy

# Delete a single file named file.txt from the current directory.
$ rm file.txt

# Create a sample file named example.txt for demonstration.
$ touch example.txt
 
# Delete the sample file named example.txt.
$ rm example.txt
 
# Verify that the file example.txt has been deleted by attempting to list it.
$ ls example.txt
ls: cannot access 'example.txt': No such file or directory

# Add an alias to .bashrc to make rm always prompt for confirmation by default.
$ echo "alias rm='rm -i'" >> ~/.bashrc
 
# Reload the .bashrc file to apply the alias immediately.
$ source ~/.bashrc

# Check if the alias for rm is set to rm -i.
$ alias rm
alias rm='rm -i'

# Create a sample file named test.txt for demonstration.
$ touch test.txt
 
# Attempt to delete the file test.txt; the alias will prompt for confirmation.
$ rm test.txt
rm: remove regular file 'test.txt'? y

# Create a directory named dir for demonstration.
$ mkdir dir
 
# Create a file named file.txt in the current directory.
$ touch file.txt
 
# Delete all files and directories in the current directory recursively.
$ rm -r *

# Install the testdisk package, which includes tools for file recovery.
$ sudo apt install testdisk
 
# Run photorec, a tool from testdisk, to attempt recovery of deleted files.
$ photorec

# Install the testdisk package for file recovery on Ubuntu/Debian systems.
$ sudo apt install testdisk
 
# Run testdisk to scan the disk and attempt to recover deleted files.
$ testdisk

# Delete all files in the current directory (non-recursive, files only).
$ rm *

# List all files with the .txt extension to preview what will be deleted.
$ ls *.txt
file1.txt  file2.txt
 
# Delete all files with the .txt extension after verifying the list.
$ rm *.txt

# Create sample files named file1.txt and file2.txt for demonstration.
$ touch file1.txt file2.txt
 
# Delete all files with the .txt extension in the current directory.
$ rm *.txt
 
# Verify that all .txt files are deleted by attempting to list them.
$ ls *.txt
ls: cannot access '*.txt': No such file or directory

# Create a directory named dir for demonstration.
$ mkdir dir
 
# Create a file named file.txt inside dir to make it non-empty.
$ touch dir/file.txt
 
# Attempt to remove the directory dir with rmdir; this will fail because it’s not empty.
$ rmdir dir
rmdir: failed to remove 'dir': Directory not empty
 
# Remove the directory dir and its contents recursively using rm -r.
$ rm -r dir

# Remove a write-protected file named readonly.txt without prompting using the -f option.
$ rm -f readonly.txt

# Create a file named readonly.txt for demonstration.
$ touch readonly.txt
 
# Set read-only permissions (444) on readonly.txt to make it write-protected.
$ chmod 444 readonly.txt
 
# Force delete the write-protected file readonly.txt without prompting.
$ rm -f readonly.txt
 
# Verify that the file readonly.txt is deleted by attempting to list it.
$ ls readonly.txt
ls: cannot access 'readonly.txt': No such file or directory

# Create a target file named target.txt.
$ touch target.txt
 
# Create a symbolic link named link.txt pointing to target.txt.
$ ln -s target.txt link.txt
 
# Remove the symbolic link named link.txt.
$ rm link.txt
$ ls target.txt
target.txt

# Install the trash-cli package to enable moving files to a trash bin instead of deleting them.
$ sudo apt install trash-cli
 
# Move a file named file.txt to the trash bin using trash-put.
$ trash-put file.txt

# Create a trash directory in the home folder to store moved files.
$ mkdir ~/.trash
 
# Add an alias named trash to .bashrc to move files to ~/.trash with numbered backups.
$ echo "alias trash='mv --backup=numbered -t ~/.trash'" >> ~/.bashrc
 
# Reload the .bashrc file to apply the alias immediately.
$ source ~/.bashrc
 
# Use the trash alias to move a file named file.txt to ~/.trash.
$ trash file.txt

# Create a sample file named file.txt for demonstration.
$ touch file.txt
 
# Move the file file.txt to the trash directory using the trash alias.
$ trash file.txt
 
# Verify that the file file.txt is in the trash directory.
$ ls ~/.trash
file.txt

# Create a directory named folder for demonstration.
$ mkdir folder
 
# Attempt to remove the directory named folder without options; this will fail.
$ rm folder
rm: cannot remove 'folder': Is a directory

# Remove the directory named folder and its contents recursively (if any).
$ rm -r folder
 
# Verify that the directory folder is deleted by attempting to list it.
$ ls folder
ls: cannot access 'folder': No such file or directory

# Delete multiple files named file1.txt and file2.txt in one command.
$ rm file1.txt file2.txt

# Create sample files named file1.txt and file2.txt for demonstration.
$ touch file1.txt file2.txt
 
# Delete both files file1.txt and file2.txt in a single command.
$ rm file1.txt file2.txt
 
# Verify that both files are deleted by attempting to list them.
$ ls file1.txt file2.txt
ls: cannot access 'file1.txt': No such file or directory
ls: cannot access 'file2.txt': No such file or directory

# Create a file named readonly.txt for demonstration.
$ touch readonly.txt
 
# Set read-only permissions (444) on readonly.txt to make it write-protected.
$ chmod 444 readonly.txt
 
# Force delete the write-protected file readonly.txt without prompting using -f.
$ rm -f readonly.txt

# Verify that the file readonly.txt is deleted by attempting to list it.
$ ls readonly.txt
ls: cannot access 'readonly.txt': No such file or directory

# Create a file named protected.txt for demonstration.
$ touch protected.txt
 
# Set read-only permissions (444) on protected.txt to make it write-protected.
$ chmod 444 protected.txt
 
# Attempt to delete the write-protected file protected.txt; it will prompt for confirmation.
$ rm protected.txt
rm: remove write-protected regular file 'protected.txt'? y

# Remove a directory named dir and its contents recursively.
$ rm -r dir

# Create a directory named dir with a subdirectory sub.
$ mkdir -p dir/sub
 
# Create a file named file.txt inside dir/sub.
$ touch dir/sub/file.txt
 
# Recursively delete the directory dir and its contents.
$ rm -r dir
 
# Verify that the directory dir is deleted by attempting to list it.
$ ls dir
ls: cannot access 'dir': No such file or directory

# Create a file named file.txt for demonstration.
$ touch file.txt
 
# Force delete the file file.txt without prompting using -f.
$ rm -f file.txt
 
# Create a directory named dir.
$ mkdir dir
 
# Create a file named file.txt inside dir.
$ touch dir/file.txt
 
# Force recursively delete the directory dir and its contents without prompting using -rf.
$ rm -rf dir

# Check if file.txt exists and delete it only if it does.
$ [ -f file.txt ] && rm file.txt

# Create a sample file named file.txt for demonstration.
$ touch file.txt
 
# Delete the file file.txt if it exists using a conditional check.
$ [ -f file.txt ] && rm file.txt
 
# Verify that the file file.txt is deleted by attempting to list it.
$ ls file.txt
ls: cannot access 'file.txt': No such file or directory

# Delete all files with the .log extension in the current directory.
$ rm *.log

# Find files older than 30 days in the current directory and prompt for confirmation before deletion.
$ find . -type f -mtime +30 -exec rm -i {} \;

# Create a file named old.txt with a modification time older than 30 days.
$ touch -d "31 days ago" old.txt
 
# Find and delete files older than 30 days with a prompt for confirmation.
$ find . -type f -mtime +30 -exec rm -i {} \;
rm: remove regular file './old.txt'? y

# Create a file named large.txt for demonstration.
$ touch large.txt
 
# Delete the file large.txt.
$ rm large.txt
 
# Check the disk usage of the current directory to confirm space is freed.
$ df -h .