Variables are vital if you want to write scripts and understand what that code you’re about to cut and paste from the web will do to your Linux computer. We’ll get you started!
Variables are named symbols that represent either a string or numeric value. When you use them in commands and expressions, they are treated as if you had typed the value they hold instead of the name of the variable.
To create a variable, you just provide a name and value for it. Your variable names should be descriptive and remind you of the value they hold. A variable name cannot start with a number, nor can it contain spaces. It can, however, start with an underscore. Apart from that, you can use any mix of upper- and lowercase alphanumeric characters.
Here, we’ll create five variables. The format is to type the name, the equals sign
=, and the value. Note there isn’t a space before or after the equals sign. Giving a variable a value is often referred to as assigning a value to the variable.
We’ll create four string variables and one numeric variable,
To see the value held in a variable, use the
echo command. You must precede the variable name with a dollar sign
$ whenever you reference the value it contains, as shown below:
Let’s use all of our variables at once:
echo "$my_boost is to $me as $his_boost is to $him (c) $this_year"
The values of the variables replace their names. You can also change the values of variables. To assign a new value to the variable,
my_boost, you just repeat what you did when you assigned its first value, like so:
If you re-run the previous command, you now get a different result:
echo "$my_boost is to $me as $his_boost is to $him (c) $this_year"
So, you can use the same command that references the same variables and get different results if you change the values held in the variables.
We’ll talk about quoting variables later. For now, here are some things to remember:
- A variable in single quotes
'is treated as a literal string, and not as a variable.
- Variables in quotation marks
"are treated as variables.
- To get the value held in a variable, you have to provide the dollar sign
- A variable without the dollar sign
$only provides the name of the variable.
You can also create a variable that takes its value from an existing variable or number of variables. The following command defines a new variable called
drink_of_the_Year, and assigns it the combined values of the
How to Use Variables in Scripts
Scripts would be completely hamstrung without variables. Variables provide the flexibility that makes a script a general, rather than a specific, solution. To illustrate the difference, here’s a script that counts the files in the
Type this into a text file, and then save it as
fcnt.sh (for “file count”):
#!/bin/bash folder_to_count=/dev file_count=$(ls $folder_to_count | wc -l) echo $file_count files in $folder_to_count
Before you can run the script, you have to make it executable, as shown below:
chmod +x fcnt.sh
Type the following to run the script:
This prints the number of files in the
/dev directory. Here’s how it works:
- A variable called
folder_to_countis defined, and it’s set to hold the string “/dev.”
- Another variable, called
file_count, is defined. This variable takes its value from a command substitution. This is the command phrase between the parentheses
$( ). Note there’s a dollar sign
$before the first parenthesis. This construct
$( )evaluates the commands within the parentheses, and then returns their final value. In this example, that value is assigned to the
file_countvariable. As far as the
file_countvariable is concerned, it’s passed a value to hold; it isn’t concerned with how the value was obtained.
- The command evaluated in the command substitution performs an
lsfile listing on the directory in the
folder_to_countvariable, which has been set to “/dev.” So, the script executes the command “ls /dev.”
- The output from this command is piped into the
-l(line count) option causes
wcto count the number of lines in the output from the
lscommand. As each file is listed on a separate line, this is the count of files and subdirectories in the “/dev” directory. This value is assigned to the
- The final line uses echo to output the result.
But this only works for the “/dev” directory. How can we make the script work with any directory? All it takes is one small change.
How to Use Command Line Parameters in Scripts
Many commands, such as
wc, take command line parameters. These provide information to the command, so it knows what you want it to do. If you want
ls to work on your home directory and also to show hidden files, you can use the following command, where the tilde
~ and the
-a (all) option are command line parameters:
ls ~ -a
Our scripts can accept command line parameters. They’re referenced as
$1 for the first parameter,
$2 as the second, and so on, up to
$9 for the ninth parameter. (Actually, there’s a
$0, as well, but that’s reserved to always hold the script.)
You can reference command line parameters in a script just as you would regular variables. Let’s modify our script, as shown below, and save it with the new name
#!/bin/bash folder_to_count=$1 file_count=$(ls $folder_to_count | wc -l) echo $file_count files in $folder_to_count
This time, the
folder_to_count variable is assigned the value of the first command line parameter,
The rest of the script works exactly as it did before. Rather than a specific solution, your script is now a general one. You can use it on any directory because it’s not hardcoded to work only with “/dev.”
Here’s how you make the script executable:
chmod +x fcnt2.sh
Now, try it with a few directories. You can do “/dev” first to make sure you get the same result as before. Type the following:
You get the same result (207 files) as before for the “/dev” directory. This is encouraging, and you get directory-specific results for each of the other command line parameters.
To shorten the script, you could dispense with the variable,
folder_to_count, altogether, and just reference
$1 throughout, as follows:
#!/bin/bash file_count=$(ls $1 wc -l) echo $file_count files in $1
Working with Special Variables
$0, which is always set to the filename of the script. This allows you to use the script to do things like print its name out correctly, even if it’s renamed. This is useful in logging situations, in which you want to know the name of the process that added an entry.
The following are the other special preset variables:
- $#: How many command line parameters were passed to the script.
- $@: All the command line parameters passed to the script.
- $?: The exit status of the last process to run.
- $$: The Process ID (PID) of the current script.
- $USER: The username of the user executing the script.
- $HOSTNAME: The hostname of the computer running the script.
- $SECONDS: The number of seconds the script has been running for.
- $RANDOM: Returns a random number.
- $LINENO: Returns the current line number of the script.
You want to see all of them in one script, don’t you? You can! Save the following as a text file called,
#!/bin/bash echo "There were $# command line parameters" echo "They are: $@" echo "Parameter 1 is: $1" echo "The script is called: $0" # any old process so that we can report on the exit status pwd echo "pwd returned $?" echo "This script has Process ID $$" echo "The script was started by $USER" echo "It is running on $HOSTNAME" sleep 3 echo "It has been running for $SECONDS seconds" echo "Random number: $RANDOM" echo "This is line number $LINENO of the script"
Type the following to make it executable:
chmod +x special.sh
Now, you can run it with a bunch of different command line parameters, as shown below.
Bash uses environment variables to define and record the properties of the environment it creates when it launches. These hold information Bash can readily access, such as your username, locale, the number of commands your history file can hold, your default editor, and lots more.
To see the active environment variables in your Bash session, use this command:
env | less
If you scroll through the list, you might find some that would be useful to reference in your scripts.
How to Export Variables
When a script runs, it’s in its own process, and the variables it uses cannot be seen outside of that process. If you want to share a variable with another script that your script launches, you have to export that variable. We’ll show you how to this with two scripts.
First, save the following with the filename
#!/bin/bash first_var=alpha second_var=bravo # check their values echo "$0: first_var=$first_var, second_var=$second_var" export first_var export second_var ./script_two.sh # check their values again echo "$0: first_var=$first_var, second_var=$second_var"
This creates two variables,
second_var, and it assigns some values. It prints these to the terminal window, exports the variables, and calls
script_two.sh terminates, and process flow returns to this script, it again prints the variables to the terminal window. Then, you can see if they changed.
The second script we’ll use is
script_two.sh. This is the script that
script_one.shcalls. Type the following:
#!/bin/bash # check their values echo "$0: first_var=$first_var, second_var=$second_var" # set new values first_var=charlie second_var=delta # check their values again echo "$0: first_var=$first_var, second_var=$second_var"
This second script prints the values of the two variables, assigns new values to them, and then prints them again.
To run these scripts, you have to type the following to make them executable:
chmod +x script_one.sh chmod +x script_two.sh
And now, type the following to launch
This is what the output tells us:
- script_one.sh prints the values of the variables, which are alpha and bravo.
- script_two.sh prints the values of the variables (alpha and bravo) as it received them.
- script_two.sh changes them to charlie and delta.
- script_one.sh prints the values of the variables, which are still alpha and bravo.
What happens in the second script, stays in the second script. It’s like copies of the variables are sent to the second script, but they’re discarded when that script exits. The original variables in the first script aren’t altered by anything that happens to the copies of them in the second.
How to Quote Variables
You might have noticed that when scripts reference variables, they’re in quotation marks
". This allows variables to be referenced correctly, so their values are used when the line is executed in the script.
If the value you assign to a variable includes spaces, they must be in quotation marks when you assign them to the variable. This is because, by default, Bash uses a space as a delimiter.
Here’s an example:
Bash sees the space before “Geek” as an indication that a new command is starting. It reports that there is no such command, and abandons the line.
echo shows us that the
site_name variable holds nothing—not even the “How-To” text.
Try that again with quotation marks around the value, as shown below:
This time, it’s recognized as a single value and assigned correctly to the
echo Is Your Friend
It can take some time to get used to command substitution, quoting variables, and remembering when to include the dollar sign.
Before you hit Enter and execute a line of Bash commands, try it with
echo in front of it. This way, you can make sure what’s going to happen is what you want. You can also catch any mistakes you might have made in the syntax.