In this guide, we will cover how to use variables in bash script.
In Unix/Linux, if you want to automate the repetitive tasks then it is recommended to use bash script and if required schedule it via crontab. A bash script contains a setup commands, loops and variables.
Variables are the building blocks of the programming language. They allow us to refer to a memory location using a name. With help of variables, we can assign, read, and manipulate values stored at a particular memory location. In addition to this, carefully chosen variable names improve the readability of the program.
Variable Naming Rules and Conventions
Like other programming languages, there are some rules and conventions that need to be followed while working with variables in bash.
Let’s discuss the rules first:
- A variable name can only have alphanumeric characters (letters and digits) and underscore
- Variable name must start with either a letter or an underscore character
- Variable names are case-sensitive. It means msg and MSG are totally two different variables
The conventions are not rules but these are widely accepted best practices. Let’s discuss the conventions related to variable naming:
- All variables are defined using the UPPER-CASE letters
- An underscore character is used to improve readability. For example, a variable FIRST_NAME is more readable than FIRSTNAME
Working With Variables
In this section, we will see how to assign and display the value of a variable. Then we will see how to unset the value of a variable. Finally, we will see how to create a write protected variable.
We can assign a value to a variable using an assignment operator as follows:
$ MSG="Hello, World"
We can use the Dollar($) symbol with a variable to print its value:
$ echo $MSG Hello, World
Additionally, we can also use the assignment operator to overwrite the value of the variable:
$ MSG="New Value" $ echo $MSG New Value
In bash, we can use the unset command to clear the value of the variable. Let’s see this with an example:
$ echo $MSG New Value $ unset MSG $ echo $MSG $
In the above output, the last line is blank which represents a variable without a value. Please note that, we should not use a Dollar($) symbol with the unset command.
In a larger script, we often see that many variables are used. Remembering the name and location of every variable is an impossible task. In such cases, there are chances that someone might overwrite an existing variable inadvertently. To avoid such scenarios, we can use the readonly command to make the variable write-protected.
$ MSG="Read-only message" $ readonly MSG $ echo $MSG Read-only message
Now, let’s try to modify the MSG variable and observe the behavior:
$ MSG="Modified message" bash: MSG: readonly variable
The operation failed as expected with a read-only variable error.
Exporting a Variable
In bash, by default variables are scoped to the current process only. It means the variable defined in the parent process is not visible to its children by default. Let’s understand this with an example:
First, define a new variable and print its value:
$ MESSAGE="Hello, World" $ echo $MESSAGE Hello, World
Now, let’s launch another instance of the bash shell and print the value of the same variable:
$ bash $ echo $MESSAGE $
In the above output, we can see that the value of the variable is empty.
To overcome this limitation, we can use the export command. This command makes the parent process’ variables visible to their children.
To understand this, we need to perform the following operations in order:
- Exit from the child’s shell
- Export variable in the parent shell
- Launch a new instance of the bash shell as a child process
- Print value of the variable
Here, we can see that the child process can see the parent process’ variable.
Storing Command’s Output to a Variable
Sometimes, we need to store the command output in the variable. In such scenarios, we can either use a Backquotes(`) or command substitution operator. With this approach, the shell executes the command first and then stores the output in a variable.
$ CUR_DIR=`pwd` $ echo "Current directory = $CUR_DIR" Current directory = /tmp
We can achieve the same result using the command substitution operator as well:
$ CUR_DIR=$(pwd) $ echo "Current directory = $CUR_DIR" Current directory = /tmp
In bash, there are three types of variables:
User Defined Variables
These variables are created by the user explicitly. The variables which we created in previous sections are examples of user defined variables. The scope of this variable is limited to the current process and its children only.
System Defined Variables
Users don’t create these variables. Instead, these variables are created by the Operating System(OS) itself. Unlike user defined variables, these variables are available to each and every process running on the system.
Some of the commonly used variables of this type are – PWD, USER, SHELL, HOSTNAME, etc.
We can use the env command to list all system defined variables:
The above command generates the following output:
As the name suggests these are the special variables used by the bash. These variables are available to all the users of the system.
Let’s see the some of the commonly used special variable in the bash:
Find the Current Process Name
We can use the $0 variable to find the name of the current process. Let’s find the name of the current shell using this:
$ echo $0 bash
Now, let’s change the shell and execute the same command again:
$ sh $ echo $0 sh
If we execute the same command from the script then it prints the script name.
Find the Exit Status of the Command
We can use the $? variable to find the exit status of the last executed command. The zero value represents the successful whereas the non-zero value represents the unsuccessful command execution.
Let’s run the command which can be executed successfully and observe the return value:
$ ls -d /tmp/ /tmp/ $ echo $? 0
Now, let’s run the command which will generate an error:
$ ls non-existing-file ls: cannot access 'non-existing-file': No such file or directory $ echo $? 2
In the above examples, we can see that the ls command returned zero for the existing directory and non-zero for the non-existing file.
Find the Process ID of the Current Shell
We can use the $$ variable to find the process id of the current shell. Let’s find the process id of the bash using this:
$ echo "Process ID of the current shell = $$" Process ID of the current shell = 16504
Let’s verify that the result is correct using the pgrep command:
$ pgrep bash 16504
In this guide, we discussed how to create and use variables. Then we saw how to store command output in the variable. Finally, we discussed the different types of variables available in the bash.