Bash Scripting: Control Structures

A Quick Refresher: What is a Bash Script?

Remember from our early Linux lessons, a shell script is simply a text file containing a sequence of commands. When you run the script, the shell executes these commands one by one. To make scripts more powerful, we need to add logic.

All our scripts will start with a shebang: #!/bin/bash. This line tells the system to execute the script using the Bash interpreter.

And to run a script, you first need to make it executable:
chmod +x your_script_name.sh

Then, you can run it like this:
./your_script_name.sh

Now, let's add some intelligence to our scripts.

1. Making Decisions with if, elif, and else

The if statement is the most fundamental control structure. It allows your script to execute a block of code only if a certain condition is true.

The basic syntax is:

if [ condition ]; then
  # code to execute if condition is true
fi

Notice the crucial details:

• There are spaces inside the square brackets [ ].
• The statement ends with fi (if spelled backward).

You can add an else block to execute code when the condition is false, and elif (else if) to check for multiple conditions.

if [ condition1 ]; then
  # code for condition1
elif [ condition2 ]; then
  # code for condition2
else
  # code if no conditions are met
fi

To learn the syntax and the essential comparison operators you'll use inside the [ ], please read the following sections from the "Bash Scripting Tutorial".

A very common task in DevOps is checking for the existence of files or directories before trying to use them. This prevents errors in your scripts. The if statement is perfect for this.

For a practical example, look at how to check if a file exists in the "25 Practical Linux Bash Script Examples" article.

#!/bin/bash

DIRECTORY="/var/log"

if [ -d "$DIRECTORY" ]; then
  echo "Log directory found."
else
  echo "Log directory not found."
fi

2. Repeating Actions with Loops

Loops are used to execute a block of code multiple times. This is essential for automating tasks that involve multiple items, like processing a list of servers, files, or users.

The for Loop: Iterating Over a List

A for loop is ideal when you have a known set of items you want to iterate through.

The syntax is:

for variable in item1 item2 item3; do
  # code to execute for each item
  # you can use $variable here
done

for loops are incredibly versatile. You can loop over a static list, a sequence of numbers, or the output of another command.

The while Loop: Looping While a Condition is True

A while loop continues to execute as long as its control condition is true. This is perfect for when you don't know in advance how many times you need to loop.

The syntax is:

while [ condition ]; do
  # code to execute as long as condition is true
done

To see the syntax and examples for both for and while loops, let's return to the "Bash Scripting Tutorial".

Now let's look at some more practical examples of these loops in action.

3. Alternative Control Structures

While if, for, and while are the workhorses of Bash scripting, it's useful to know about two other structures.

• until loop: This is the opposite of a while loop. It runs until a condition becomes true.
• case statement: This is a cleaner way to handle multiple choices, acting as a powerful alternative to a long chain of if/elif statements.

You can find excellent examples of both the until loop and case statements in the resources you've already reviewed (LINK and LINK). We won't dive deep into them now, but it's good to know they exist for when you need them.

#!/bin/bash

for i in {1..5}; do
  if (( i % 2 == 0 )); then
    echo "$i is Even"
  else
    echo "$i is Odd"
  fi
done

Conclusion

You've just learned the fundamental building blocks of logic in Bash scripting. With these tools, you can move beyond simple command sequences and start writing powerful scripts that automate real-world tasks.

Key Takeaways:

• if, elif, else: Use these to make decisions and execute different code paths based on conditions.
• Comparison Operators: You must use the correct operators for numbers (-eq, -gt, etc.) and strings (=, !=). File tests (-f, -d) are also essential.
• for loop: Best for iterating over a known list of items (e.g., files in a directory, a list of servers).
• while loop: Best for looping an unknown number of times until a specific condition is met (e.g., reading a file line by line, waiting for a process to finish).

In our next lesson, we will make our scripts even more flexible and powerful. You'll learn how to handle command-line arguments and options, allowing you to pass information into your scripts when you run them.