Control Flow: Conditionals and Loops

1. Making Decisions with Conditional Statements

The most fundamental way to add logic to a script is with an if statement. It allows your script to ask a question and perform an action based on the answer. The basic structure is:

if [ condition ]; then
  # command(s) to run if the condition is true
fi

The if statement checks the "condition." In Bash, a condition is essentially a command. If the command succeeds (returns an exit code of 0), the condition is considered "true," and the code inside the then...fi block is executed.

Let's watch a video that breaks this down.

Adding an else Block

What if the condition is false? You can provide an alternative set of commands using an else block. This creates an "if this, then that; otherwise, do this other thing" structure.

if [ condition ]; then
  # code to run if true
else
  # code to run if false
fi

This is more efficient than writing two separate if statements. The next part of the video explains this clearly.

Conditional Operators: The Heart of the Condition

The "condition" inside the [ ... ] is where you perform tests. You can compare numbers, check strings, or verify file properties. There are different operators for each purpose.

To get a comprehensive overview of the most common operators you'll use, please review the tables in the following article. You don't need to memorize them all now, but it's crucial to know what's possible and where to look them up.

For example:

• [ $count -gt 10 ]: Is the value of count greater than 10?
• [ "$username" = "root" ]: Is the value of username equal to "root"? (Remember to quote your variables!)
• [ -f "/etc/hosts" ]: Does the regular file /etc/hosts exist?

A Practical Example: Checking for Files

One of the most common uses for if statements in system administration scripts is to check for the existence of files or directories before trying to act on them. This prevents errors and makes scripts more robust.

The video below demonstrates this by checking if a file or command exists and then taking action. This is a very practical skill.

#!/bin/bash

APP_DIR="/tmp/my_app"

if [ -d "$APP_DIR" ]; then
  echo "Directory $APP_DIR already exists."
else
  echo "Creating directory $APP_DIR..."
  mkdir "$APP_DIR"
fi

2. Automating Repetitive Tasks with Loops

Loops are for when you need to perform the same action multiple times. Instead of writing the same command over and over, you can put it in a loop. We'll cover the two main types: for and while.

The for Loop: Iterating Over a List

A for loop is perfect for when you have a known set of items (like a list of files, servers, or usernames) and you want to do something with each one.

The basic syntax is:

for variable_name in item1 item2 item3; do
  # command(s) to run for each item
  # use $variable_name to access the current item
done

Let's see this in action.

A more practical use is to iterate over files. You can use wildcards (like *) to generate the list of items dynamically.

The while Loop: Looping Based on a Condition

A while loop is used when you want to repeat a block of code as long as a certain condition remains true. You might not know how many iterations are needed beforehand.

The syntax is:

while [ condition ]; do
  # command(s) to run as long as the condition is true
  # IMPORTANT: Something inside the loop must eventually make the condition false!
done

The resource below provides a clear, simple example of a while loop that uses a counter.

Loop Control: break and continue

Sometimes you need to alter the flow of a loop.

• break: Exits the loop immediately.
• continue: Skips the rest of the current iteration and starts the next one.

#!/bin/bash

for logfile in *.log; do
  # Check if the file actually exists to avoid errors if no .log files are found
  if [ -f "$logfile" ]; then
    echo "Processing $logfile..."
  fi
done

Conclusion

You have now learned the fundamental control structures that give your scripts logic and power. With conditionals and loops, you can create scripts that adapt to different situations and automate complex, repetitive tasks.

Key Takeaways:

• if [ condition ]; then ... fi: Use for decision-making. Add else or elif (else if) for more complex logic.
• Conditional Operators: Use operators like -gt (numeric), = (string), and -f (file) inside the [ ... ] to perform tests.
• for item in list; do ... done: Use to iterate over a known set of items, like files or a range of numbers.
• while [ condition ]; do ... done: Use to loop as long as a condition is true, especially when the number of iterations is not known in advance.
• break and continue: Use to control the flow from within a loop.

Preview of the Next Lesson:

Our scripts can now make decisions and repeat tasks, but they are still self-contained. In the next lesson, we will learn how to "Accept and process user input and command-line arguments in scripts." This will allow you to pass information into your scripts when you run them, making them interactive and even more versatile. For example, instead of hardcoding a directory path, you could provide it as an argument, allowing the same script to work on any directory you choose.