Understanding the Bash Shell – Variables, Aliases, and Scripting Basics • GTech Booster

Bash, short for Bourne Again SHell, is a command line interpreter used on most Linux systems and on macOS for many years by default. A shell is the program that sits between a person and the operating system, reading the commands a user types and translating them into actions the computer carries out. When someone opens a terminal window on a Linux machine, there is a very good chance Bash is the shell interpreting everything they type.

Bash is more than a place to run one command at a time. It is also a full scripting language, capable of storing information, making decisions, repeating tasks, and automating entire workflows. Understanding variables, aliases, and basic scripting turns Bash from a simple command runner into a genuinely powerful tool for controlling a computer.

Variables in Bash

A variable is a named container that holds a piece of information, such as a word, a number, or a file path, so that it can be reused without retyping it every time. Variables are one of the most fundamental building blocks of any scripting language, and Bash is no exception.

Creating and Using a Variable

In Bash, a variable is created simply by writing its name, an equals sign, and the value, with no spaces around the equals sign. For example:

bash

name="Alex"

To use the value stored inside a variable, a dollar sign is placed in front of its name:

bash

echo "Hello, $name"

This would print “Hello, Alex” to the screen. The dollar sign tells Bash to substitute the variable’s value in place of its name wherever it appears.

Environment Variables

Some variables are not created by the user but already exist as part of the system, holding information the operating system or other programs rely on. These are called environment variables. A common example is the HOME variable, which stores the path to the current user’s home directory, or the PATH variable, which lists the directories Bash searches through when looking for a program to run. Environment variables are typically written in uppercase letters by convention, helping distinguish them from variables a user creates.

Quoting and Why It Matters

Bash treats quotation marks carefully, and the type of quote used changes how a variable behaves. Double quotes allow variable substitution to happen normally, meaning a variable inside double quotes is still replaced with its value. Single quotes, however, treat everything literally, meaning a variable inside single quotes is not substituted at all. This distinction matters greatly once a script grows in complexity, since misunderstanding it is a common source of unexpected behavior.

Aliases in Bash

An alias is a shortcut that lets a user assign a short, memorable name to a longer or more complex command. Aliases exist purely for convenience, helping avoid the need to type a long command repeatedly throughout the day.

Creating an Alias

An alias is created using the alias keyword, followed by the shortcut name, an equals sign, and the full command in quotes:

bash

alias ll="ls -la"

After running this, typing ll in the terminal behaves exactly as though the user had typed ls -la, which lists all files in a directory along with detailed information about each one.

Making Aliases Permanent

An alias created directly in the terminal only lasts for that particular terminal session, disappearing once the terminal is closed. To make an alias available every time a new terminal session starts, it needs to be added to a configuration file that Bash reads automatically, most commonly a file named .bashrc located in the user’s home directory. Once added there and the file is reloaded or a new terminal is opened, the alias becomes a permanent part of that user’s environment.

Why Aliases Are Useful

Aliases are especially helpful for commands that are long, hard to remember, or used frequently throughout the day. A person managing files might create an alias for a command that lists files sorted by size, while a developer might create one that runs a specific set of testing commands with a single short word. Over time, well chosen aliases can meaningfully speed up daily work at the terminal.

Scripting Basics

A script is simply a text file containing a sequence of Bash commands, saved so that all of those commands can be executed together, in order, by running the file once. Scripting allows repetitive or complex tasks to be automated rather than typed manually every time.

The Shebang Line

Nearly every Bash script begins with a special first line called a shebang, which tells the system which interpreter should be used to run the file:

bash

#!/bin/bash

This line looks like a comment, since it starts with a hash symbol, but the combination of hash and exclamation mark at the very beginning of a file has special meaning to the operating system, instructing it to use Bash to execute everything that follows.

Writing and Running a Simple Script

A basic script might look like this:

bash

#!/bin/bash
echo "Starting backup process"
mkdir -p backup
cp important_file.txt backup/
echo "Backup complete"

This script announces that a backup is starting, creates a folder named backup if it does not already exist, copies a file into that folder, and then announces that the process is finished. Once saved to a file, such as backup.sh, the script needs to be made executable before it can run, which is done with the following command:

bash

chmod +x backup.sh

After that, the script can be run by typing:

bash

./backup.sh

Using Variables in Scripts

Scripts commonly rely on variables to avoid repeating the same value multiple times and to make the script easier to adjust later. For example:

bash

#!/bin/bash
folder_name="backup"
mkdir -p "$folder_name"
echo "Created folder: $folder_name"

If the folder name ever needs to change, only the single line defining the variable needs to be updated, rather than every line that references it.

Conditional Statements

Scripts often need to make decisions based on certain conditions, which is handled using an if statement. For example:

bash

#!/bin/bash
if [ -f "important_file.txt" ]; then
    echo "File found, proceeding with backup"
else
    echo "File not found, backup skipped"
fi

This script checks whether a file exists before deciding whether to continue, demonstrating how scripts can respond intelligently to the state of the system rather than blindly running every command regardless of circumstances.

Loops

Loops allow a script to repeat an action multiple times without writing the same command over and over. A common example is a for loop that processes several files one after another:

bash

#!/bin/bash
for file in *.txt
do
    echo "Processing $file"
done

This script goes through every file ending in .txt within the current directory, one at a time, printing a message for each one, illustrating how a small amount of code can handle a task across many files automatically.

Bringing It All Together

Variables, aliases, and scripting each serve a distinct purpose within Bash, yet together they transform the shell from a simple command line into a genuine automation environment. Variables allow information to be stored and reused, reducing repetition and making commands more flexible. Aliases shorten frequently used commands into quick, memorable shortcuts, saving time during everyday terminal use. Scripts combine commands, variables, conditions, and loops into a single reusable file capable of performing complex, multi step tasks with a single execution.

Anyone spending meaningful time working in a Linux terminal will find that a solid grasp of these three concepts unlocks a level of efficiency and control that simply typing individual commands one at a time cannot match.