Create and remove a directory in Linux in Easy Steps

In this article, brought to you by Orcacore, we aim to demonstrate how to create and remove a directory in Linux using straightforward methods and practical examples. A directory, fundamentally, is a designated space within your computer’s file system where you store and organize files. These directories are integral to hierarchical file systems, commonly found in operating systems like Linux, MS-DOS, OS/2, and Unix. Let’s dive into the process of creating and managing directories within a Linux environment. To create and remove a directory in Linux, you’ll need access to a Linux server. Once logged in, you can follow the steps outlined below. We’ll start with creating directories.

Step 1 – How to Create a Directory in Linux?

The primary command for creating directories in Linux is mkdir. To create a directory named "orca," you would use the following command:

# mkdir orca

To verify the successful creation of the directory, use the ls command:

ls

The output should include the newly created directory:

Output
orca

How to Create Multiple Directories?

You can efficiently create multiple directories at once by listing their names, separated by spaces, after the mkdir command:

mkdir directory1 directory2 directory3

Important Note: Ensure that the directory names are separated by spaces.

How to Create Parent Directories?

When creating a directory structure where parent directories might not exist, you can use the mkdir command with the -p switch. This option creates any necessary parent directories automatically.

mkdir -p directory1/directory2/directory3

In this example, if directory1 and directory2 do not exist, mkdir will create them before creating directory3.

Note: The tree command is a useful tool for visualizing the directory structure:

tree directory1

Here are the most commonly used switches of the mkdir command:

(The original article doesn’t list any switches here, so I’m leaving this as is.)

If you lack the necessary permissions to use the mkdir command, you may need to use sudo to execute the command with administrator privileges, or contact your system administrator.

Step 2 – How to Remove a Directory in Linux?

The rmdir command is used to remove empty directories. To remove the "orca" directory, you would use:

rmdir orca

Note: rmdir can only remove empty directories. If the directory contains files or subdirectories, the command will fail.

Remove Directories with rm

The rm command is a more versatile tool for deleting files and directories. Unlike rmdir, rm can remove both empty and non-empty directories.

By default, rm does not remove directories without specific options. To delete an empty directory, use the -d (or --dir) option. To delete a non-empty directory and all its contents recursively, use the -r (or -R) option.

rm -d orca
rm -r orca

Conclusion

At this point, you have learned to create and remove a directory in Linux in Easy Steps. You can easily use the mkdir command to create directories and the rm command to remove directories. Hope you enjoy it.

Also, you may like to read the following articles:

12 Commands to Check Linux System and Hardware Information

Commands to Get Public IP Address

Display PID of a Process in Linux Terminal

Configure Linux Users Passwords with chpasswd Command

15 Cmdlets PowerShell Examples

Alternative Solutions for Directory Creation and Removal

While mkdir and rm (with its variants) are the standard tools, here are two alternative approaches to directory creation and removal in Linux, offering different levels of abstraction and control:

1. Using Shell Scripting with Error Handling

This approach provides more control and allows for error handling during the creation and removal processes. Instead of directly using mkdir and rm, we embed them within a shell script with checks to ensure the operations are successful. This is particularly useful in automated scripts or environments where robustness is critical.

Example Script for Directory Creation:

#!/bin/bash

DIR_NAME="my_new_directory"

# Check if the directory already exists
if [ -d "$DIR_NAME" ]; then
  echo "Directory '$DIR_NAME' already exists."
  exit 1 # Exit with an error code
fi

# Attempt to create the directory
mkdir "$DIR_NAME"
if [ $? -eq 0 ]; then
  echo "Directory '$DIR_NAME' created successfully."
else
  echo "Failed to create directory '$DIR_NAME'."
  exit 1 # Exit with an error code
fi

exit 0 # Exit with success code

Explanation:

• #!/bin/bash: Shebang line specifying the interpreter for the script.
• DIR_NAME="my_new_directory": Defines a variable to store the directory name, making the script more readable and maintainable.
• if [ -d "$DIR_NAME" ]; then: Checks if the directory already exists using the -d flag. The quotes around $DIR_NAME are crucial to handle directory names with spaces.
• mkdir "$DIR_NAME": Attempts to create the directory.
• if [ $? -eq 0 ]; then: Checks the exit status of the mkdir command. $? holds the exit code of the last executed command. A value of 0 indicates success.
• exit 1: Exits the script with an error code of 1 if the directory already exists or if the creation fails. This allows calling scripts to detect failures.
• exit 0: Exits the script with a success code of 0 if the directory is created successfully.

Example Script for Directory Removal (with safety measures):

#!/bin/bash

DIR_NAME="my_new_directory"

# Check if the directory exists
if [ ! -d "$DIR_NAME" ]; then
  echo "Directory '$DIR_NAME' does not exist."
  exit 1
fi

# Double-check that we're not accidentally deleting something important.
# This is a crucial safety measure!
if [[ "$DIR_NAME" == "/" || "$DIR_NAME" == "." || "$DIR_NAME" == ".." ]]; then
    echo "ERROR: Refusing to delete root, current, or parent directory!"
    exit 1
fi

# Ask for confirmation before deleting (optional, but recommended)
read -p "Are you sure you want to delete '$DIR_NAME' and all its contents? (y/n): " -n 1 -r
echo    # (optional) move to a new line
if [[ ! $REPLY =~ ^[Yy]$ ]]
then
    echo "Deletion cancelled."
    exit 0
fi

# Attempt to remove the directory recursively
rm -rf "$DIR_NAME"
if [ $? -eq 0 ]; then
  echo "Directory '$DIR_NAME' and its contents deleted successfully."
else
  echo "Failed to delete directory '$DIR_NAME'."
  exit 1
fi

exit 0

Explanation:

• Includes robust checks to prevent accidental deletion of important directories (root, current, or parent).
• Prompts the user for confirmation before proceeding with the deletion, adding an extra layer of safety.
• Uses rm -rf to recursively remove the directory and its contents. Caution: This command is powerful and can be destructive if used carelessly.
• Checks the exit status of the rm command for success or failure.

This scripting approach offers significantly greater control and safety compared to directly using rmdir or rm. This method is recommended for critical operations.

2. Using Python for Cross-Platform Compatibility and Advanced Features

Python provides a higher-level abstraction and cross-platform compatibility. It also allows for more complex logic and error handling than simple shell scripts.

Example Python Code for Directory Creation:

import os

dir_name = "my_python_directory"

try:
    os.makedirs(dir_name, exist_ok=True)  # Creates directory and any necessary parent directories
    print(f"Directory '{dir_name}' created successfully.")
except OSError as e:
    print(f"Error creating directory '{dir_name}': {e}")

Explanation:

• import os: Imports the os module, which provides functions for interacting with the operating system.
• os.makedirs(dir_name, exist_ok=True): Creates the directory and any necessary parent directories. The exist_ok=True argument prevents an error if the directory already exists.
• try...except: Handles potential OSError exceptions that may occur during directory creation (e.g., permission issues).

Example Python Code for Directory Removal:

import os
import shutil

dir_name = "my_python_directory"

try:
    shutil.rmtree(dir_name, ignore_errors=False, onerror=None) # Removes directory recursively
    print(f"Directory '{dir_name}' removed successfully.")
except FileNotFoundError:
    print(f"Directory '{dir_name}' not found.")
except OSError as e:
    print(f"Error removing directory '{dir_name}': {e}")

Explanation:

• import shutil: Imports the shutil module, which provides high-level file operations, including recursive directory removal.
• shutil.rmtree(dir_name, ignore_errors=False, onerror=None): Recursively removes the directory and its contents.
  • ignore_errors=False raises an exception if an error occurs during removal.
  • onerror=None specifies a function to handle errors during removal (can be customized for more advanced error handling).
• try...except: Handles potential exceptions like FileNotFoundError and OSError.

Python’s approach offers cross-platform compatibility, allowing the same code to work on different operating systems with minimal modification. It also provides a more structured way to handle errors and implement complex logic.

These alternative methods provide more robust and controlled ways to create and remove a directory in Linux than the basic commands, especially when dealing with automated scripts or critical operations where error handling and safety are paramount. Remember to carefully consider the specific requirements of your task when choosing the appropriate method.