Beginner’s Guide: mkdir Command in Linux with Examples

The mkdir command is a powerful tool in Linux that allows users to create new directories or folders in their file system.

Whether you’re a beginner or an experienced Linux user, understanding how to use this command is essential for managing your files and directories efficiently.

In this article, we will provide a comprehensive guide to the mkdir command in Linux, with examples that demonstrate its basic syntax, as well as more advanced features like creating nested directories and setting directory permissions.

To begin, we will introduce the basic syntax of the mkdir command and provide examples of how to create a single directory or multiple directories at once.

We will also cover how to create nested directories, which is a useful feature for organizing files and subdirectories. Additionally, we will explain how to set directory permissions using the chmod command, which is essential for controlling access to your files and directories.

Furthermore, we will explore how to combine the mkdir command with other Linux commands to perform more complex tasks, such as creating directories with specific permissions or creating directories based on a list of names. We will also discuss common errors that users may encounter when using the mkdir command and provide troubleshooting tips to help resolve these issues. Finally, we will offer best practices for using the mkdir command to ensure that you are using it effectively and efficiently.

Key Takeaways

• The mkdir command is a powerful tool for creating directories in Linux.
• Users can create single or multiple directories, as well as nested directories.
• Setting directory permissions and combining mkdir with other commands can enhance its functionality.

Understanding the Mkdir Command

The mkdir command is a command-line utility used to create new directories (folders) in Linux. This command is used to create a new directory with the specified name under the current directory or the directory specified in the command.

The basic syntax of the mkdir command is as follows:

mkdir [options] directory_name

Here, directory_name specifies the name of the directory that you want to create. The options parameter can be used to modify the behavior of the mkdir command.

For example, if you want to create a new directory called “my_folder” in the current directory, you can use the following command:

mkdir my_folder

By default, the mkdir command creates a directory with read, write, and execute permissions for the owner, and read and execute permissions for the group and others.

You can use the -m option to specify the permissions for the new directory. For example, to create a new directory called “my_folder” with read, write, and execute permissions for the owner, and read-only permissions for the group and others, you can use the following command:

mkdir -m 755 my_folder<br>

In this example, the 755 value specifies the permissions for the new directory. The first digit (7) specifies the permissions for the owner, the second digit (5) specifies the permissions for the group, and the third digit (5) specifies the permissions for others.

You can also use the -p option to create a directory and any necessary parent directories. For example, to create a new directory called “my_folder” inside a directory called “parent_folder” that does not exist, you can use the following command:

mkdir -p parent_folder/my_folder

In this example, the -p option ensures that the “parent_folder” directory is created if it does not already exist, and then creates the “my_folder” directory inside it.

Overall, the mkdir command is a simple yet powerful utility that can be used to create directories in Linux with ease.

Basic Mkdir Command Syntax

The mkdir command in Linux is used to create directories or folders. The basic syntax of the mkdir command is as follows:

mkdir [OPTIONS] DIRECTORY

Here, OPTIONS are the various flags that can be used with the mkdir command and DIRECTORY is the name of the directory that needs to be created.

For example, to create a directory named “mydir”, the following command can be used:

mkdir mydir

This will create a directory named “mydir” in the current working directory.

Multiple directories can be created simultaneously by specifying their names separated by spaces. For example, to create directories named “dir1”, “dir2”, and “dir3”, the following command can be used:

mkdir dir1 dir2 dir3

This will create three directories named “dir1”, “dir2”, and “dir3” in the current working directory.

The mkdir command also provides several options that can be used to modify its behavior. Some of the commonly used options are:



For example, to create a directory named “mydir” and all its parent directories if they do not exist, the following command can be used:

mkdir -p /path/to/mydir<br>

This will create a directory named “mydir” in the directory “/path/to” if it exists, or create the directories “/path/to” and “mydir” if they do not exist.

In summary, the mkdir command is a simple yet powerful tool that can be used to create directories in Linux. Its basic syntax is straightforward, and its options provide flexibility to meet various requirements.

Creating a Single Directory

To create a single directory using the mkdir command in Linux, the user needs to specify the directory name as an argument to the command. For example, to create a directory named “mydir”, the user can use the following command:

mkdir mydir

If the directory name contains spaces or special characters, the user needs to enclose the name in quotes. For example, to create a directory named “my dir”, the user can use the following command:

mkdir "my dir"

The mkdir command also allows the user to set the permissions for the new directory using the -m option. For example, to create a directory named “mydir” with read, write, and execute permissions for the owner and read and execute permissions for others, the user can use the following command:

mkdir -m 755 mydir

In this example, the first digit of the permission code (7) specifies the permissions for the owner, the second digit (5) specifies the permissions for the group, and the third digit (5) specifies the permissions for others.

Overall, creating a single directory using the mkdir command in Linux is a simple and straightforward process that can be customized with the use of options such as setting permissions.

Creating Multiple Directories

The mkdir command in Linux can create multiple directories at once with a single command. This can be useful when you need to create a directory structure with multiple levels.

To create multiple directories, simply list the names of the directories separated by spaces after the mkdir command. For example, to create three directories named dir1, dir2, and dir3, the command would be:

mkdir dir1 dir2 dir3<br>

If you need to create directories with subdirectories, you can use the -p option to create parent directories as needed. For example, to create a directory structure with a parent directory named parent and two subdirectories named child1 and child2, the command would be:

mkdir -p parent/child1 parent/child2<br>

This will create the parent directory if it does not exist, and then create the child1 and child2 directories inside it.

You can also use variables and wildcards to create multiple directories with similar names. For example, to create directories named dir1, dir2, dir3, and so on up to dir10, you can use the following command:

mkdir dir{1..10}<br>

This will create directories with the names dir1, dir2, dir3, and so on up to dir10.

In summary, the mkdir command in Linux can create multiple directories at once, including parent directories and directories with similar names using variables and wildcards.

Creating Nested Directories

The mkdir command in Linux can be used to create multiple directories at once, including nested directories. Nested directories are directories that are created within other directories.

To create a nested directory using the mkdir command, simply specify the path of the directory you want to create, including the name of the directory and any parent directories that do not yet exist.

For example, to create a directory named my_folder inside a directory named parent_folder that does not yet exist, you can use the following command:

mkdir -p parent_folder/my_folder<br>

The -p option tells mkdir to create any necessary parent directories that do not yet exist.

You can also create multiple nested directories at once by specifying the full path of the directories you want to create:

mkdir -p parent_folder/child_folder/grandchild_folder<br>

This will create a directory named grandchild_folder inside a directory named child_folder, which is inside a directory named parent_folder.

In addition, you can use the mkdir command to create multiple directories at once, including nested directories. For example:

mkdir -p parent_folder/child_folder1 parent_folder/child_folder2<br>

This will create two directories, child_folder1 and child_folder2, inside a directory named parent_folder.

Overall, the mkdir command in Linux is a powerful tool for creating directories, including nested directories, quickly and easily.

Setting Directory Permissions

When creating a directory using the mkdir command, the default permissions are set to rwxr-xr-x. This means that the owner of the directory has full permissions, while the group and others have read and execute permissions only.

To modify the permissions of a directory, you can use the chmod command followed by the desired permissions. The permissions can be specified using either the symbolic or numeric method.

Symbolic Method

The symbolic method uses letters to represent the user, group, and others, and the actions of adding, removing, or setting permissions. The following table shows the available letters and their meanings:



For example, to give the group write permissions to a directory, you can use the following command:

chmod g+w directory_name<br>

To remove read permissions for others, you can use:

chmod o-r directory_name<br>

Numeric Method

The numeric method uses a three-digit code to represent the permissions for the user, group, and others. Each digit represents a combination of read (4), write (2), and execute (1) permissions. For example, the code 755 gives the owner full permissions, while the group and others have read and execute permissions only.

To set the permissions of a directory using the numeric method, you can use the following command:

chmod 755 directory_name<br>

It is important to note that the permissions of a directory can affect the files and subdirectories within it. Therefore, it is recommended to carefully consider the permissions before making any changes.

Combining Mkdir with Other Commands

One of the powerful features of the mkdir command is the ability to combine it with other commands to create complex directory structures. Here are a few examples:

Creating Multiple Directories at Once

To create multiple directories at once, you can use the mkdir command with the -p option. For example, the command mkdir -p /home/user/documents/projects will create the directories documents and projects inside the user directory, and the user directory inside the home directory, if they don’t already exist.

Creating Directories with Specific Permissions

You can use the mkdir command with the -m option to specify the permissions of the directory you are creating. For example, the command mkdir -m 755 /home/user/documents will create the directory documents inside the user directory with read, write, and execute permissions for the owner and read and execute permissions for everyone else.

Creating Directories with Timestamps

You can use the mkdir command with the -t option to set the timestamp of the directory you are creating to a specific time. For example, the command mkdir -t 202401271200 /home/user/documents will create the directory documents inside the user directory with a timestamp of January 27, 2024 at 12:00 PM.

Creating Directories with Different Users or Groups

You can use the mkdir command with the -o and -g options to specify the owner and group of the directory you are creating. For example, the command mkdir -o user -g group /home/user/documents will create the directory documents inside the user directory with the owner set to user and the group set to group.

By combining the mkdir command with other commands, you can create complex directory structures with specific permissions, timestamps, owners, and groups.

Troubleshooting Common Mkdir Errors

When using the mkdir command in Linux, users may encounter some errors. Here are some common errors and their solutions:

Error: “mkdir: cannot create directory ‘directory-name’: File exists”

This error occurs when the user tries to create a directory that already exists. To solve this issue, the user can either choose a different name for the directory or remove the existing directory before creating a new one. To remove an existing directory, the user can use the rmdir command followed by the directory name.

Error: “mkdir: cannot create directory ‘directory-name’: Permission denied”

This error occurs when the user does not have the necessary permissions to create a directory in the specified location. To solve this issue, the user can try creating the directory in a location where they have write permissions, or they can use the sudo command to run the mkdir command with root privileges.

Error: “mkdir: missing operand”

This error occurs when the user does not specify a directory name after the mkdir command. To solve this issue, the user should specify the name of the directory they want to create after the mkdir command.

Error: “mkdir: too many arguments”

This error occurs when the user specifies more than one directory name after the mkdir command. To solve this issue, the user should only specify one directory name after the mkdir command.

By understanding these common errors and their solutions, users can effectively use the mkdir command in Linux without encountering any issues.

Conclusion

In conclusion, the ‘mkdir’ command in Linux is a powerful tool that simplifies the process of creating directories, helping users organize files efficiently. By exploring its functionality, step-by-step creation process, batch directory creation techniques, nested directory capabilities, permission control, and verification methods, this guide has provided you with a comprehensive understanding of creating directories in Linux. With this knowledge, you can streamline your file organization, optimize your workflow, and harness the full potential of the Linux operating system.

Last Updated on January 27, 2024 by admin