July 6, 2024

11 Key Linux Commands Every User Must Learn


11 Key Linux Commands Every User Must Learn.

Linux Commands _ 99rdp

Explore More; Unlocking the Power of Grep Command in Linux: Detailed Usage, Options, and Syntax

Linux Commands

A Linux command is a directive to the Linux operating system to perform a specific task. These Linux commands are entered into the command line interface (CLI), a text-based interface that allows users to interact with the system. Linux commands are powerful tools that can perform a wide range of functions, from file manipulation and system management to network configuration and software installation. Each command typically follows a syntax that includes the command itself, followed by options (or flags) and arguments that specify the details of the task. For example, the command ls -l /home lists the contents of the /home directory in long format, providing detailed information about each file and directory. Linux commands are essential for advanced users, system administrators, and developers, as they provide direct control over the system’s operations and can be used in scripts to automate repetitive tasks. Understanding and mastering Linux commands can significantly enhance one’s ability to manage and troubleshoot Linux-based systems effectively.

11 Key Linux Commands

  • ls: Lists files and directories in the current directory.
    • Usage: ls
    • Common options: ls -l (detailed list), ls -a (include hidden files)
  • cd: Changes the current directory.
    • Usage: cd /path/to/directory
  • pwd: Prints the current working directory.
    • Usage: pwd
  • cp: Copies files or directories.
    • Usage: cp source_file destination_file
  • mv: Moves or renames files or directories.
    • Usage: mv old_name new_name
  • rm: Removes files or directories.
    • Usage: rm file
    • Common option: rm -r (remove directories and their contents)
  • mkdir: Creates a new directory.
    • Usage: mkdir new_directory
  • rmdir: Removes an empty directory.
    • Usage: rmdir directory
  • touch: Creates an empty file or updates the timestamp of an existing file.
    • Usage: touch new_file
  • cat: Concatenates and displays the contents of a file.
    • Usage: cat file
  • grep: Searches for a specified pattern in files.
    • Usage: grep "search_term" file
  • chmod: Changes the permissions of a file or directory.
  • Usage: chmod permissions file
  • Example: chmod 755 file

Let’s dive deep into LINUX COMMANDS

1. The ls command:

  • Introduction:
    • The ls command, short for “list,” is fundamental in Linux for displaying the contents of directories and files.
  • Basic Usage:
    • Firstly, the ls command without any arguments lists the files and directories in the current directory.
      • Syntax: ls
  • Specifying Directories:
    • Additionally, to list the contents of a specific directory, you can use the command with the directory path.
      • Syntax: ls /path/to/directory
  • Options for Flexibility:
    • Moreover, the ls command supports several options to enhance its functionality. Here are some common options:
  • Detailed Information (-l):
    • The -l option displays detailed information about each file, including file permissions, owner, size, and date.
      • Syntax: ls -l
  • Readable Size (-lh):
    • Furthermore, the -lh option lists files in a long format with sizes converted to human-readable formats (e.g., K for kilobytes, M for megabytes, G for gigabytes).
      • Syntax: ls -lh
  • Hidden Files (-a):
    • Next, the -a option shows hidden files, which are files that start with a dot (e.g., .filename).
      • Syntax: ls -a
  • Recursive Listing (-R):
    • Finally, the -R option lists all files and directories recursively, providing a comprehensive view of the directory tree.
      • Syntax: ls -R


  • In conclusion, the ls command is an essential and versatile tool in Linux, providing various options to display directory contents effectively. Mastering these options can significantly improve your file management efficiency in a Linux environment.

2.The cd command:

  • Introduction:
    • The cd (change directory) command in Linux is used to navigate through directories in the file system and change the current working directory in the terminal.
  • Basic Syntax:
    • To use the cd command, simply type cd followed by the directory path. Note that sudo privileges are not required for basic usage.
      • Syntax: cd <directory path>
  • Changing to the Home Directory:
    • Firstly, if you want to switch to your home directory, you can use the cd command without any arguments.
      • Syntax: cd
    • Alternatively, you can use the tilde (~) character:
      • Syntax: cd ~
  • Customizing Behavior:
    • Additionally, the cd command has several options to customize its behavior:
  • Moving Up One Directory Level (cd ..):
    • To move up one directory level from the current directory, use the following command:
      • Syntax: cd ..
  • Switching to the Previous Directory (cd -):
    • Furthermore, to change back to the previous directory you were in, use:
      • Syntax: cd -
  • Switching to Another User’s Home Directory (cd ~[username]):
    • Moreover, to switch to another user’s home directory, use the tilde followed by the username:
      • Syntax: cd ~[username]
  • Navigating to a Subdirectory (cd subdirectory_name):
    • Lastly, to navigate to a subdirectory within the current working directory, simply specify the subdirectory name:
      • Syntax: cd subdirectory_name
  • Conclusion:
    • In conclusion, the cd command is a fundamental tool for directory navigation in Linux. Understanding its options can greatly enhance your efficiency when working in the terminal.

3. The pwd command:

  • Introduction:
    • The pwd (print working directory) command in Linux is used to display the full path of the current working directory, such as /home/directory/path.
  • Basic Syntax:
    • To use the pwd command, simply type pwd in the terminal. This command can be used with or without options.
      • Syntax: pwd [options]
  • Default Behavior:
    • Firstly, without any options, the pwd command prints the full path of the current working directory.
      • Example: pwd might output /home/user/docs.
  • Customizing Output with Options:
    • Additionally, the pwd command supports options that allow you to customize its output:
  • Logical Path (-L):
    • The -L option prints the logical path of the current working directory, including any symbolic links.
      • Syntax: pwd -L
      • Example: If /home/user/docs is a symbolic link to /mnt/storage/docs, pwd -L will show /home/user/docs.
  • Physical Path (-P):
    • Furthermore, the -P option prints the actual physical path of the current directory, resolving any symbolic links.
      • Syntax: pwd -P
      • Example: Using the same symbolic link scenario, pwd -P will show /mnt/storage/docs.
  • Conclusion:
    • In conclusion, the pwd command is a simple yet essential tool for displaying the current working directory in Linux. Understanding its options allows you to get either the logical path with symbolic links or the physical path without them, enhancing your ability to navigate and manage directories effectively.

4. The cp command:

  • Introduction:
    • The cp (copy) command is a useful tool in Linux for managing the file system by copying files and directories from one location to another.
  • Basic Syntax:
    • The basic syntax of the cp command is:
      • cp [source_file] [destination_file]
    • Here, source_file is the file you want to copy, and destination_file is the location where the copied file will be placed.
  • Example Usage:
    • For instance, the command:
      • cp image.jpg ~/Downloads
    • This command copies image.jpg to the Downloads directory.
  • Restrictions:
    • Importantly, the source file and the destination file cannot be the same.
  • Creating New Files:
    • Additionally, if the destination_file does not exist, the cp command will create the specified file at the destination.
    • Conversely, if the destination_file already exists, its content will be overwritten.
  • Copying Multiple Files:
    • Furthermore, to copy multiple files to a directory, you can use the following syntax:
      • cp file1.txt file2.txt /destination_directory/
  • Prompting for Confirmation (-i option):
    • To set a prompt for confirmation before overwriting any existing files at the destination, you can use the -i option with the cp command:
      • cp -i file1.txt /destination_directory/
    • This ensures you are asked for confirmation before the command overwrites any files.
  • Conclusion:
    • In conclusion, the cp command is a versatile tool for copying files and directories in Linux. Understanding its syntax and options, such as prompting for confirmation before overwriting, can help you manage your file system efficiently and avoid accidental data loss.

5. The mv command:

  • Introduction:
    • The mv (move) command in Linux is a powerful tool for moving and renaming files and directories within the file system.
  • Basic Syntax:
    • The basic syntax for moving files using the mv command is:
      • mv [source] [destination]
  • Example: Moving Files:
    • For example, to move report.txt to the documents directory, you would use the following command:
      • mv report.txt documents/
  • Example: Renaming Files:
    • Similarly, to rename report.txt to report_final.txt, you would use:
      • mv report.txt report_final.txt
  • Example: Moving Directories:
    • Furthermore, to move a directory named dir1 to another location named dir2, the command would be:
      • mv dir1 dir2
  • Customizing Behavior with Options:
    • The mv command offers several options to customize its behavior:
  • Interactive Mode (-i):
    • Firstly, the -i option enables interactive mode, prompting for confirmation before overwriting any existing files:
      • mv -i report.txt documents/
    • This helps prevent accidental data loss.
  • Force Move (-f):
    • Moreover, the -f option forces the move operation, overwriting the destination file without any prompts:
      • mv -f report.txt documents/
    • Use this option carefully, as it will overwrite files without warning.
  • Verbose Mode (-v):
    • Additionally, the -v option enables verbose mode, providing detailed output of the actions being performed:
      • mv -v report.txt documents/
    • This can be useful for understanding exactly what the command is doing.
  • Conclusion:
    • In conclusion, the mv command is an essential tool for file and directory management in Linux. By mastering its syntax and options, such as interactive mode, force move, and verbose mode, you can effectively move and rename files and directories while minimizing the risk of errors and data loss.

6. The rm command:

  • Introduction:
    • The rm (remove) command is an important Linux tool for deleting files and directories. However, it should be used with caution.
  • Permissions:
    • Firstly, when using the rm command, ensure you have the necessary permissions to delete the specified files or directories.
  • Permanent Deletion:
    • Additionally, it’s important to note that the rm command deletes files permanently, with no undo feature in Linux. Therefore, use the rm command carefully to avoid accidental data loss.
  • Basic Syntax:
    • The basic syntax for removing a file using the rm command is:
      • rm file_name
  • Common Options:
    • The rm command supports several options to customize its behavior:
  • Recursive Deletion (-r):
    • The -r option deletes a directory and all its contents, including subdirectories and files:
      • rm -r directory_name
    • This is useful for removing entire directory structures.
  • Interactive Mode (-i):
    • Furthermore, the -i option prompts for confirmation before deleting each file:
      • rm -i file_name
    • This helps prevent accidental deletion by asking for user confirmation.
  • Force Deletion (-f):
    • Moreover, the -f option forces the deletion of files without prompting for confirmation:
      • rm -f file_name
    • Use this option with caution, as it will delete files without any warnings.


  • In conclusion, the rm command is a powerful and potentially dangerous tool for file and directory deletion in Linux. Understanding its options, such as recursive deletion, interactive mode, and force deletion, allows you to use it effectively while minimizing the risk of unintended data loss. Always double-check the files and directories you are deleting to ensure that you do not remove important data accidentally.

7. The mkdir command:

  • Introduction:
    • If you wish to create new directories in the terminal, the mkdir (make directory) command is the solution. It is a fundamental command for directory creation in Linux.
  • Basic Syntax:
    • The basic syntax for creating a single directory using the mkdir command is:
      • mkdir [option] [directory_name]
  • Creating Multiple Directories:
    • Additionally, to create multiple directories at once, you can list them within the command:
      • mkdir directory1 directory2 directory3
    • This allows you to efficiently create several directories in a single command.
  • Specifying a Path:
    • Furthermore, you can specify a path when creating a new directory. For instance, to create a directory named new/directory within path/to/, use:
      • mkdir /path/to/new/directory
    • This ensures the new directory is created at the desired location in the file system.
  • Setting Permissions (-m option):
    • Moreover, to create a directory with specific permissions, you can use the -m option with the mkdir command. For example, to create a directory with read, write, and execute permissions for all users, run:
      • mkdir -m 777 directory_name
    • This sets the directory permissions to 777, allowing all users to read, write, and execute.


  • In conclusion, the mkdir command is an essential tool for directory creation in Linux. Understanding its syntax and options, such as creating multiple directories, specifying a path, and setting permissions, enhances your ability to manage the file system efficiently and effectively.

8. The touch command:

  • Introduction:
    • The touch command in Linux is a versatile tool used for managing file creation and modification times.
  • Basic Functionality:
    • Primarily, the touch command allows you to create new empty files or update the timestamps of existing files.
  • Basic Syntax:
    • The syntax for the touch command is straightforward:
      • touch [options] [file_name]
  • Creating New Files:
    • If the specified file does not exist, the touch command creates a new empty file with the given name:
      • Example: touch newfile.txt
  • Updating Timestamps:
    • Additionally, if the file already exists, the touch command updates its last access and modification times.
  • Customizing Behavior with Flags:
    • The touch command, like other Linux commands, offers various flags for specific needs:
  • Update Access Time (-a option):
    • The -a option updates only the access time of the file:
      • Example: touch -a existingfile.txt
    • This is useful when you want to record that the file has been accessed without changing the modification time.
  • Update Modification Time (-m option):
    • Furthermore, the -m option updates only the modification time of the file:
      • Example: touch -m existingfile.txt
    • This is handy when you need to update the modification time without affecting the access time.


  • In conclusion, the touch command is an essential tool in Linux for creating files and managing their timestamps. Understanding its syntax and options, such as updating access or modification times, allows you to effectively manage file metadata and streamline your workflow.

9. The cat command:

  • Introduction:
    • The cat (concatenate) command in Linux is used to display the contents of a file on the terminal. It is beneficial for working with files, allowing you to view file contents, combine multiple files, and create new files effectively.
  • Basic Syntax:
    • The basic syntax for using the cat command is:
      • cat filename
    • This command displays the contents of filename directly in the terminal.
  • Combining Multiple Files:
    • Additionally, you can use the cat command to combine multiple files into a new one. This is done using the following syntax:
      • cat file1 file2 > newfile
    • This command concatenates the contents of file1 and file2, then redirects the output to newfile.
  • Example: Viewing File Contents:
    • For example, to view the contents of a file named example.txt, you would use:
      • cat example.txt
  • Example: Creating a New File from Multiple Files:
    • Furthermore, to create a new file that combines file1.txt and file2.txt, you would use:
      • cat file1.txt file2.txt > combinedfile.txt
    • This command merges the contents of file1.txt and file2.txt into combinedfile.txt.
  • Conclusion:
    • In conclusion, the cat command is a versatile and essential tool in Linux for file management. Understanding its basic syntax and how to combine multiple files allows you to effectively handle and manipulate file contents, making it an invaluable command for everyday tasks in a Linux environment.

10.The grep command:

  • Introduction:
    • The grep (global regular expression print) command is a versatile search tool in Linux, enabling users to search for text patterns in files. It is especially useful for filtering text and searching through command output.
  • Basic Syntax:
    • The basic syntax for using the grep command is:
      • grep [options] pattern [file...]
    • Here, pattern refers to the string or regular expressions you want to search for, and file refers to one or more files to search within.
  • Example Usage:
    • For example, to search for the string “example” in a file called file.txt, you would use:
      • grep "example" file.txt
    • This command prints all lines in file.txt that contain the string “example”.
  • Practical Applications:
    • The grep command is powerful and valuable for filtering large log files and extracting relevant information.
  • Common Options:
    • The grep command comes with numerous options to refine your search. Here are some commonly used ones:
  • Case-Insensitive Search (-i):
    • The -i option enables a case-insensitive search, allowing you to match patterns regardless of case:
      • grep -i "example" file.txt
  • Count Matching Lines (-c):
    • The -c option counts the number of matching lines instead of displaying them:
      • grep -c "example" file.txt
  • Recursive Search (-r or -R):
    • Furthermore, the -r or -R options search for patterns in all files in the current directory and its subdirectories:
      • grep -r "example" .
    • This is useful for searching through large directory structures.
  • Inverting the Search (-v):
    • The -v option inverts the search and displays lines that do not match the pattern:
      • grep -v "example" file.txt
    • This shows all lines except those containing the pattern.
  • Listing Filenames (-l):
    • Lastly, the -l option lists filenames that contain the pattern:
      • grep -l "example" *.txt
    • This is useful for quickly identifying which files contain the search pattern.


  • In conclusion, the grep command is an essential tool in Linux for searching and filtering text in files and command output. By understanding its syntax and options, such as case-insensitive search, counting matches, recursive search, inverting the search, and listing filenames, you can effectively manage and analyze large amounts of text data.

11. The chmod and chown commands

  • Introduction to chmod:
    • By mastering the chmod command, you can effectively manage file access permissions (read, write, and execute) in Linux.
  • Basic Syntax:
    • The basic syntax for the chmod command is:
      • chmod [options] [permission] [filename]
  • Understanding Permissions:
    • Permissions are set using a combination of three attributes:
      • r (Read), w (Write), and x (Execute).
    • These permissions can be applied to three types of users:
      • Owner (u), Group (g), and Others (o).
  • Numeric (Octal) Values:
    • Additionally, you can use numeric values to set permissions:
      • Read = 4, Write = 2, Execute = 1.
    • For example, to set read, write, and execute permissions (rwx), you sum the values to get 7.
  • Example: Numeric Representation:
    • To set read, write, and execute permissions for the owner, and read and execute permissions for the group and others, use:
      • chmod 755 file.txt
  • Example: Symbolic Representation:
    • Furthermore, to set owner permissions to read, write, and execute, and group and others to read-only, use:
      • chmod u=rwx,go=r file.txt
    • The = symbol sets exact permissions, while - removes and + adds permissions.

Changing Ownership with chown:

  1. Introduction to chown:
    • The chown command is used for changing the ownership of a file or directory.
  2. Basic Syntax:
    • The basic syntax for the chown command is:
      • chown [options] user[:group] file
  3. Changing Ownership:
    • To change the file ownership, replace user with the username or user ID and group with the group name or group ID (optional).
    • For example, to change the owner of file.txt to Opera, use:
      • chown Opera file.txt
  4. Administrative Privileges:
    • Note that administrative privileges (sudo) are required to run these commands effectively.


In conclusion, by mastering the chmod and chown commands, you can effectively manage file permissions and ownership in Linux. Understanding the syntax and options of these commands allows you to set specific access levels and control who can modify and access files, enhancing security and proper file management.

11 Key Linux Commands Every User Must Learn is plated here .

Explore More; How to Mount and Unmount an ISO Drive in Linux




Popular Blog Posts