Shell Scripting with Variables and Command Substitution

1. What is a Shell Script?

At its core, a shell script is just a plain text file containing a sequence of commands that you would otherwise type into your terminal one by one. The shell (in our case, Bash) reads this file and executes the commands in order. It's the most fundamental way to automate tasks on a Linux system.

Creating and running your first script involves three simple steps:

1. Create a text file.
2. Write your commands in the file.
3. Make the file executable and run it.

To see exactly how this is done, the following reading provides a concise guide.

Let's quickly summarize those key components:

• The Shebang (#!/bin/bash): This must be the very first line of your script. It tells the operating system which interpreter to use to run the commands in the file. In this case, it's the Bash shell. While scripts might run without it on your system if Bash is the default, including it makes your script portable and unambiguous.
• Comments (#): Any line beginning with a # (except the shebang) is a comment. The shell ignores it. Use comments to explain what your script does and why.
• Permissions (chmod +x): Before you can run a script directly (e.g., ./my_script.sh), you must give it "execute" permission. This is a security feature in Linux that prevents accidental execution of files.

2. Making Scripts Dynamic with Variables

Hardcoding values directly into a script is limiting. For scripts to be reusable and dynamic, they need to work with data that can change. This is where variables come in. A variable is simply a name that refers to a piece of data, like a string of text or a number.

Declaring and Using Variables

The syntax for creating a variable is straightforward.

# Assigning a string value to a variable
GREETING="Hello, World!"

# Assigning a number
USER_COUNT=5

# Using (accessing) the variables
echo $GREETING
echo "There are $USER_COUNT users online."

There are two critical syntax rules to remember:

1. No spaces around the equals sign (=). NAME = "John" will fail. It must be NAME="John".
2. When you use or reference a variable's value, you prefix its name with a dollar sign ($), like $GREETING.

A best practice is to enclose your variables in double quotes when you use them (e.g., echo "$GREETING"). This prevents the shell from misinterpreting spaces or special characters within the variable's value.

Interactive Scripts: Reading User Input

You can make your scripts interactive by prompting the user for input and storing it in a variable using the read command.

The following resource provides a simple, practical example.

3. Command Substitution: Capturing Command Output

This is an incredibly powerful feature. Command substitution allows you to run a command and "capture" its output, typically to store it in a variable or use it as part of another command.

The modern and recommended syntax is $(command).

For example, if you want to store your current working directory in a variable, you can capture the output of the pwd command:

CURRENT_DIR=$(pwd)
echo "You are currently in: $CURRENT_DIR"

Let's look at another practical example that combines this with what we've learned.

As you can see, this lets you integrate the output of any Linux command right into your script's logic, which is essential for automation.

#!/bin/bash

# Get the number of files by listing them and counting the lines
FILE_COUNT=$(ls -1 | wc -l)

# Print the result
echo "The current directory contains $FILE_COUNT files."

chmod +x file_counter.sh
./file_counter.sh

4. Passing Information with Command-Line Arguments

Instead of prompting a user for input every time, you can design scripts to accept arguments directly from the command line. These are called positional parameters.

The shell makes these arguments available through special variables:

• $1: The first argument.
• $2: The second argument, and so on.

There are other special variables that provide useful context about how the script was run:

• $0: The name of the script itself.
• $#: The total number of arguments passed to the script.
• $@: All arguments passed to the script, treated as separate words.

The following resource introduces these concepts with clear examples.

Now, let's see them in action.

This ability to pass arguments makes your scripts far more flexible and powerful, turning them into reusable tools.

A Glimpse into How the Shell Works

It can be helpful to have a mental model of how the shell processes a command you type. It's not a single, monolithic action. The shell performs a series of expansions in a specific order.

You don't need to memorize this chart, but notice where our topics for today fit in:

• Parameter expansion (using $VAR)
• Command substitution (using $(cmd))
• Arithmetic substitution (using $((...)))

These happen before the shell executes the final command. This is why you can write echo "Today is $(date)", and the shell first runs date, substitutes its output, and only then runs echo with the final string.

Conclusion

Great work! You've just taken a huge leap from being a command-line user to a command-line automator. You now have the foundational tools to write scripts that are dynamic, interactive, and can leverage the full power of other Linux commands.

Key Takeaways:

• A shell script is a text file of commands, starting with a shebang like #!/bin/bash.
• Scripts must be made executable with chmod +x before being run.
• Variables store data (NAME="value") and are accessed with a $ (echo "$NAME").
• Command substitution (VAR=$(command)) captures the output of a command into a variable.
• Positional parameters ($1, $2, etc.) allow you to pass arguments to your script from the command line.
• Special variables like $# (argument count) and $@ (all arguments) provide useful context.

This lesson concludes our module on Linux Fundamentals. You've built a solid base, from navigating the filesystem to managing processes and now writing basic scripts.

In our next lesson, we will begin a new module: Linux System Administration Essentials. Our first topic will be managing users and groups. You'll see very quickly how the scripting skills you learned today can be used to automate common administrative tasks.