Overriding Commands in Bash

LINUX
FUNDAMENTALS A Complete Guide for Beginners Enroll Course Now

Enroll Course Now

Overriding commands refers to making custom implementations of a built-in or external command. The best way to override a command is to use bash functions. You can also create aliases for the command you are trying to override. Moreover, manipulating the environment variable also offers a great way to achieve this task. Overriding commands is crucial when you want to execute a command with multiple options avoiding repetition.

This article will describe how to override commands in bash, why it’s significant, and how you can leverage it to enhance your workflow.

Why Do We Override Commands in Bash?

Overriding commands in Bash empowers users to develop customized commands, facilitating the streamlined execution of complicated commands. Let’s say, you want to run the ls command with -lih options and wish to avoid writing the whole commands repeatedly, just replace the command with ls to obtain a similar functionality by overriding it.

Here are a few reasons why you should override commands in bash:

• Personalization: Overriding commands makes it possible to modify the behavior of the command according to the user’s preferences.
• Improved Functionality: Overriding commands allows users to add more features to existing commands. For example, replacing the command “ls” with the command “ls -ilh” improves the performance of the command.
• Enhanced Productivity: Overriding lets you create a shortcut for a long command that saves time and increases productivity.
• Environment Management: When working with a particular version or project where command names are not different, you can override the command names to use your favorite one within the shell session or forever.
• Troubleshooting and debugging: For troubleshooting and debugging purposes, users can customize commands temporarily.

How to Override Commands in Bash?

In Bash, you can enable 3 ways to override commands. Let’s explore each of them in detail:

1. Using Bash Function

Bash functions allow the users to override commands by creating a function name with the overridden command name or defining a function inside the “.bashrc” file. Here you go:

1.1 Overriding Commands Within Scripts

Creating a function with the same name as the command to override is the simplest way to make a customized command within a Bash script. In this example, the ls -lih command will be overridden by the ls command with the help of a Bash function. After that, whenever you call the ls command within the script, it will execute the ls -lih command. Here’s how:

#!/bin/bash 

#Script to override command using Bash function   
ls () { 
    command ls -lih  
}
ls

All the contents of the home directory are displayed with their inode number and human-readable file sizes.

1.2 Overriding Commands Permanently in Terminal

To override commands permanently in the terminal, the function can be produced inside the “.bashrc” file making it permanent to shell sessions (does not end once the shell session terminates). For that purpose, open the .bashrc file using the nano command and follow the steps below:

1. Type nano .bashrc in the terminal.
2. Write the following script at the end of the file, changing the behavior of the pwd command:

   pwd() {
       echo "You are here: $(command pwd)"
   }

3. After writing the script inside the .bashrc file, type CTRL+S to save and CTRL+X to exit.
4. To apply the changes made in the .bashrc file, source the file by writing the following command:

   source ~/.bashrc

   Now, you will get the following output for the pwd command:
   
   

unset -f pwd

2. By Creating Aliases

In Bash, aliases can override commands by generating shortcuts or alternate names for commands either in the terminal or in the “.bashrc” file. This approach helps to save the user time and effort. Moreover, It helps to create a custom behavior for a specific command. Now, follow this command to understand how to create an alias for the grep command to override it:

alias grep='grep --color=auto'

Once you have created the alias for the grep command, run the following command to see the matched colorized patterns:

grep "Linuxsimply" file.txt

The overridden command searches for the pattern “Linuxsimply” in the “file.txt” and displays the colorized pattern.

To make the alias permanent, consider writing the alias grep='grep --color=auto' command inside the “.bashrc” file. The overridden command will run even though the current shell session has ended.

unalias grep

3. Using Environmental Variable

Consider using environmental variables in the custom script to override commands. This allows you to change the functionality of the command without changing the source code. To do this, follow the steps below:

1. Create a Bash script you want to override. For instance, I am going to replace the default output of the date command by writing the following script inside the nano text editor:

   #!/bin/bash
   date "+%A, %B %d, %Y - %H:%M:%S"

   EXPLANATION

   The format string “+%A, %B %d, %Y – %H:%M:%S” specifies how the date and time should be represented. Here’s the breakdown of the format:

   • %A: Full weekday name (e.g., Monday, Tuesday).
   • %B: Full month name (e.g., January, February).
   • %d: Day of the month (01 to 31).
   • %Y: Year (e.g., 2024).
   • %H: Hour (00 to 23).
   • %M: Minute (00 to 59).
   • %S: Second (00 to 59).
2. Make the script executable by typing chmod +x my_command.sh. Then, set an environmental variable named DATE that holds the path to the custom script:

   export DATE="/home/mou/my_command.sh"

3. Now, create an alias “date” for the DATE environmental variable so that each time you enter the date command, the output from the “DATE” variable is executed:

   alias date="$DATE"

4. Run the “date” command to see the custom output as follows:

How to Prevent Overriding Bash Function?

It is important to protect the override of the Bash function in order to keep the script’s integrity and avoid unexpected output. Here are some ways to do this:

1. Using “readonly” Attribute

Use “readonly” attribute to make the function read-only, protecting the function from being overridden. Here’s how you can do it:

readonly -f my_function

This command will prevent overriding the my_function by utilizing the readonly attribute.

2. Choosing Unique Names

Don’t use built-in command names as the function name. This will cause the function to be overridden. To make a function name unique, add unique identifiers or namespaces before the function name. For example: _my_function or my.function, etc.

3. Encapsulating in a Script

If you don’t want to accidentally override your functions, encapsulate them in a separate script and source that file in the main script. Here’s how:

1. Create a script named “my_script.sh” and define a function there:

   my_function() {
   # Function code here
   }

2. Now, source the “my-script” in the “main_script.sh” to use the “my_function” without worrying about being overridden:

   source my_script.sh
   my_function

Conclusion

Overriding commands allows users to customize the behavior of commands. After reading this article you will get to know the importance of overriding commands and how to do it. Here, I have demonstrated 3 methods including 2 cases to override commands in bash. Moreover, I have explained how to prevent a function from accidentally being overridden. Pick any method that better suits your needs. Good luck!

People Also Ask

How can I override Linux commands?

To overwrite Linux commands, use the Bash function and replace the name of the function with the name of the command, or create an alias for the command. You can also set an environment variable to perform this task. For example: to override the ls command with ls -lh, define a function named “ls” and then write command ls -lh inside the function. After that, when you call the “ls” function, it will run the “ls -lh” command instead of the ls command.

What are bash commands?

Bash commands are the shell commands that you can run inside the Bash shell. These commands allow users to manage files and directories, navigate through a system, and control various types of data.

What is overriding command?

Overriding commands is a mechanism for replacing the existing command with a new command. It can change the functionality of the default commands. Like, replacing the “ls” command with “ls -li” so that it will execute the ls -li whenever you write ls in the terminal.

How do I override a file in terminal?

To override the contents of the file in the terminal, you can use the redirection operator > along with the echo or cat command. Suppose, you want to override the output of the cat command to the existing contents of the “file.txt”. To do so, use cat > file.txt. Besides, if you want to override the text “welcome to Linuxsimply” directly into the “file.txt”, use echo "welcome to Linuxsimply" > file.txt.

How do you use override function?

To use override function, just redefine the override function with the same name as the original function. Here you go:

# Define the original function
original_function() {
echo "Original function"
}

# Call the original function
original_function

# Redefine the original function with a new implementation
original_function() {
echo "Overridden function"
}

# Call the overridden function
original_function

How to revert overriding Bash function?

To revert the overriding of the Bash functions, you can use “unset -f” followed by the function name. If you wish to revert the overriding of the pwd command, type unset -f pwd in the terminal.

Why overriding commands is useful?

Overriding commands is useful when you don’t want to write the long command repeatedly or you want to create a short name for the command. It also helps in creating custom commands. Overriding command saves users time, effort, and improves productivity and efficiency.

Related Articles

• How to Define a Function in Bash [2 Methods]
• Variables in Bash Function [Easy Reference]
• How to Call a Function in Bash [7 Cases]
• How to Add Options in a Bash Script [2 Methods]
• How to Use Alias And Functions in Bash [Reference Manual]
• Argument in Bash Script
• Return Values From Bash Function
• Bash Function Examples

<< Go Back to Bash Functions | Bash Scripting Tutorial