Control Structures: if, for, while

In Shell scripting, control structures form the backbone of logical operations and flow management. Understanding how to use these structures effectively allows you to handle conditions, repeat tasks, and make decisions in your scripts. In this article, we'll cover the three primary control structures in Shell: the if, for, and while statements. Let’s dive right in!

The `if` statement

The if statement in Shell scripts allows you to execute commands conditionally. This means you can run certain commands only when specific criteria are met. The basic syntax of an if statement looks like this:

if [ CONDITION ]; then
    # commands to be executed if CONDITION is true
fi

Syntax Breakdown

if: Initiates the statement.
[ CONDITION ]: Checks for a condition; this could be file existence, string comparison, arithmetic tests, etc.
then: Marks the start of the commands to run when the condition is true.
fi: Ends the if block.

Example: Simple If Condition

Here’s an example of how to check if a file exists:

FILE="example.txt"
if [ -f "$FILE" ]; then
    echo "$FILE exists."
else
    echo "$FILE does not exist."
fi

In this example, the script checks for the existence of example.txt. If it exists, it outputs a confirming message. If not, it informs that the file does not exist.

Using Else and Elif

You can expand the if statement with else and elif for additional conditions:

if [ CONDITION1 ]; then
    # commands if CONDITION1 is true
elif [ CONDITION2 ]; then
    # commands if CONDITION2 is true
else
    # commands if neither condition is true
fi

Example: If-Elif-Else

NUM=5
if [ $NUM -gt 10 ]; then
    echo "Greater than 10"
elif [ $NUM -gt 5 ]; then
    echo "Greater than 5"
else
    echo "5 or less"
fi

In this example, the script evaluates the variable NUM and provides an output based on its value.

Logical Operators

Shell scripting allows the use of logical operators (&& and ||) to chain conditions. Here's an example using &&:

if [ -f "$FILE" ] && [ -r "$FILE" ]; then
    echo "$FILE exists and is readable."
fi

The `for` loop

The for loop is designed to iterate over a sequence of items, such as lists or ranges. The basic syntax of a for loop is as follows:

for VARIABLE in ITEM1 ITEM2 ITEM3; do
    # commands to be executed for each ITEM
done

Example: Simple For Loop

Here’s a straightforward example that prints each item in a list:

for ITEM in apple banana cherry; do
    echo "Fruit: $ITEM"
done

This loop goes through a list of fruits and prints each one during each iteration.

Looping Through a Range

You can also loop through a range of numbers using C-style syntax:

for (( i=1; i<=5; i++ )); do
    echo "Current count: $i"
done

This loop starts at 1 and continues incrementing i until it reaches 5, printing the value of i at each step.

Nested For Loops

For loops can be nested within other loops, providing powerful capabilities for handling multi-dimensional data:

for i in 1 2 3; do
    for j in A B C; do
        echo "i: $i, j: $j"
    done
done

This will produce all combinations of i and j values.

The `while` loop

The while loop is used to execute a block of commands repeatedly as long as a specified condition evaluates to true. Its syntax is as follows:

while [ CONDITION ]; do
    # commands to be executed while CONDITION is true
done

Example: Simple While Loop

Here’s an example of a while loop that prints numbers until a condition fails:

count=1
while [ $count -le 5 ]; do
    echo "Count: $count"
    ((count++))  # Increment count
done

In this example, the loop continues to print the value of count as long as count is less than or equal to 5.

Breaking Out of Loops

Sometimes, you might want to exit a loop prematurely. You can use the break command:

counter=1
while true; do
    echo "Counter: $counter"
    if [ $counter -eq 5 ]; then
        break
    fi
    ((counter++))
done

Continue Statement

You can also skip to the next iteration of the loop using the continue command:

counter=0
while [ $counter -lt 10 ]; do
    ((counter++))
    if [ $((counter % 2)) -eq 0 ]; then
        continue  # Skip even numbers
    fi
    echo "Odd number: $counter"
done

In this example, only odd numbers will be printed because even numbers are skipped.

Combining Control Structures

You can mix control structures to create more complex scripts depending on your needs. For example, using a for loop within an if statement:

for FILE in *.txt; do
    if [ -f "$FILE" ]; then
        echo "Processing $FILE"
    fi
done

This snippet processes all .txt files in the current directory and checks if each is a regular file before proceeding.

Conclusion

Understanding control structures such as if, for, and while is crucial for effective Shell scripting. These elements allow you to create dynamic and responsive scripts that can handle a variety of conditions and iterate over data. As you become more familiar with these structures, you'll be able to tackle increasingly complex scripting tasks with confidence.

Control structures are the building blocks of scripting logic. As you practice, try experimenting with different combinations of these statements to see how you can make your scripts more efficient and effective. Happy scripting!

Programming - Shell