Scripting Essentials: Variables, Substitution, and Quoting

1. Storing Information with Variables

The first step to making a script dynamic is giving it a way to store and manage data. In scripting, we do this using variables. Think of a variable as a labeled container where you can put a piece of information, like a username, a filename, or a number, and then refer to it by its label later.

a) Declaring and Referencing Variables

Let's watch a video that introduces the fundamental syntax for working with variables.

As the video demonstrated, there are two key rules:

1. To assign a value: Use the format variable_name=value. It is critical that there are no spaces on either side of the = sign.
2. To read a value: Prefix the variable name with a dollar sign ($), like $variable_name. The $ tells the shell to substitute the variable's name with its stored value.

For example:

# Assignment (no spaces around =)
server_name="web-01"

# Referencing (with $)
echo "Connecting to server: $server_name"

b) Variable Naming Conventions and Scope

A good practice is to name your variables in a way that makes their purpose clear. In bash scripting, there's a helpful convention:

• lowercase_with_underscores: Use this for variables you create inside your own scripts (e.g., file_path, user_count).
• ALL_CAPS: This is reserved for environment variables, which are system-wide variables that are always available, like $USER (your username) or $HOME (your home directory path).

Following this convention prevents you from accidentally overwriting an important system variable and makes your scripts easier for others to read.

To learn more about this and see why variables are so useful, please watch two more clips from the same video.

#!/bin/bash
current_user=USER
echo "Hello, current_user"

#!/bin/bash
current_user=$USER
echo "Hello, $current_user"

#!/bin/bash
echo "Hello, $USER"

2. Controlling Expansion with Quoting

You may have noticed the different uses of single (') and double (") quotes. Their behavior is one of the most important concepts in shell scripting for preventing errors.

• Single Quotes ('...'): Preserve the literal value of every character. Nothing is substituted. $USER inside single quotes is treated as the four characters $, U, S, E, R.
• Double Quotes ("..."): Allow for substitution (or expansion). The shell will replace variables ($variable) and a few other special characters with their values. This is what you usually want when you're working with variables.

This distinction is crucial when your variables contain spaces or special characters.

Let's see a direct comparison.

Best Practice: When in doubt, enclose your variables in double quotes ("$variable"). This prevents the shell from splitting the variable's value if it contains spaces and ensures predictable behavior.

For example, if filename="my report.docx", then rm "$filename" will correctly delete the single file named "my report.docx". Without quotes, rm $filename would try to delete two separate files: "my" and "report.docx".

3. Capturing Output with Command Substitution

Variables are great for storing static text, but what if you need to store information that changes, like the current date, the system's IP address, or a list of files? For this, we use command substitution.

Command substitution allows you to run a command and "capture" its output, which you can then use as part of another command or assign to a variable.

The modern and recommended syntax is $(command).

For instance, to store the current date and time in a variable, you would write:

now=$(date)
echo "The report was generated at: $now"

The shell first executes the date command inside the $() and then substitutes the entire $(date) expression with the command's output.

The following video and image illustrate this powerful feature.

A common use case is creating dynamically named files, like a daily backup.

# Create a backup archive with today's date in the filename.
# The +%F option for date formats it as YYYY-MM-DD.
tar -czf "backup-$(date +%F).tar.gz" /var/www

If you run this today, it might create a file named backup-2023-10-27.tar.gz. Run it tomorrow, and the filename will be different. This is the power of dynamic scripting.

Conclusion

You've now learned the three fundamental techniques for making scripts flexible and powerful. These concepts are used in nearly every non-trivial shell script.

Key Takeaways:

• Variables store data using the name=value syntax and are retrieved with $name. Use lowercase for your script variables.
• Quoting is essential for controlling how the shell interprets text. Double quotes (") allow variable and command substitution, while single quotes (') treat everything as a literal string.
• Command Substitution $(...) lets you execute a command and use its output within another command or assign it to a variable, making your scripts dynamic.

Preview of the Next Lesson:

With the ability to store and manage data, the next logical step is to make your scripts perform actions based on that data. In the next lesson, we will "Implement conditional statements (if/then/else) and loops (for, while) in scripts." This will unlock the ability to add decision-making logic and perform repetitive actions, transforming your scripts into true programs.