How To Write A For Loop In Shell Script: A Comprehensive Guide

Shell scripting, especially with tools like Bash, is a powerful way to automate tasks. One of the most fundamental control structures in any scripting language is the for loop. This guide will walk you through everything you need to know about writing for loops in shell script, making you proficient in automating repetitive operations. We’ll cover various loop types, syntax variations, and practical examples to solidify your understanding.

Understanding the Core Concept of a For Loop

A for loop is designed to execute a block of code repeatedly. It iterates over a sequence of items, performing a set of commands for each item in that sequence. This sequence can be a list of words, numbers, files, or anything else you can define. The beauty of for loops lies in their ability to streamline processes, saving you time and effort.

The Basic Syntax: Iterating Through a List

The simplest form of a for loop iterates through a predefined list of words. The syntax is straightforward and easy to grasp.

for VARIABLE in WORD1 WORD2 WORD3 ... WORDN
do
  # Commands to be executed for each word
  echo "The word is: $VARIABLE"
done

In this example:

  • for is the keyword indicating the start of the loop.
  • VARIABLE is a variable that takes on the value of each word in the list during each iteration.
  • in is the keyword that specifies the sequence of items to iterate over.
  • WORD1 WORD2 WORD3 ... WORDN is the list of words.
  • do marks the beginning of the code block to be executed.
  • echo "The word is: $VARIABLE" is the command that will be executed for each word.
  • done marks the end of the loop.

Let’s see a concrete example:

for fruit in apple banana cherry; do
  echo "I like $fruit"
done

This script will output:

I like apple
I like banana
I like cherry

Looping Through Numbers: The seq Command

Often, you’ll need to iterate through a sequence of numbers. While you could manually list the numbers, the seq command is much more efficient. seq generates a sequence of numbers.

for i in $(seq 1 5); do
  echo "Iteration number: $i"
done

This will output:

Iteration number: 1
Iteration number: 2
Iteration number: 3
Iteration number: 4
Iteration number: 5

The seq command takes arguments to specify the start, end, and increment values (although increment defaults to 1). For example, to iterate from 10 to 20 with an increment of 2:

for i in $(seq 10 2 20); do
  echo "Number: $i"
done

This would output:

Number: 10
Number: 12
Number: 14
Number: 16
Number: 18
Number: 20

Iterating Through Files: Processing Multiple Files

A very common use case for for loops is processing files. You can iterate through a list of files, performing operations on each one.

for file in *.txt; do
  if [ -f "$file" ]; then  # Check if the file exists
    echo "Processing file: $file"
    # Add your commands to process the file here, e.g.,
    # cat "$file"  # Display the file's contents
  fi
done

In this example:

  • *.txt is a wildcard that matches all files ending with “.txt” in the current directory.
  • -f "$file" is a file existence check. The if statement ensures that the script only attempts to process existing files.
  • Inside the do block, you would place the commands to process each file.

Important: Be mindful of spaces and special characters in filenames. Always quote the $file variable to prevent issues.

Advanced For Loop Techniques: C-Style Loops

Bash also supports a C-style for loop, which offers more control over the loop’s execution, particularly useful when dealing with numerical iterations.

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

This is functionally equivalent to the seq example, but it provides a more compact syntax. The structure is: for (( initialization; condition; increment )).

  • i=1: Initializes the counter variable i to 1.
  • i <= 5: Specifies the loop’s condition; the loop continues as long as i is less than or equal to 5.
  • i++: Increments the counter variable i after each iteration.

Nested For Loops: Looping Within Loops

You can nest for loops to create more complex logic. This is helpful when you need to iterate through multiple dimensions or combinations of items.

for i in 1 2 3; do
  echo "Outer loop: $i"
  for j in a b c; do
    echo "  Inner loop: $j"
  done
done

This script would output:

Outer loop: 1
  Inner loop: a
  Inner loop: b
  Inner loop: c
Outer loop: 2
  Inner loop: a
  Inner loop: b
  Inner loop: c
Outer loop: 3
  Inner loop: a
  Inner loop: b
  Inner loop: c

Using For Loops with Arrays

Shell scripts allow you to work with arrays. You can use for loops to iterate over the elements of an array.

my_array=("apple" "banana" "cherry")

for element in "${my_array[@]}"; do
  echo "Fruit: $element"
done
  • "${my_array[@]}" expands to all elements of the array, preventing word splitting issues that can occur without the quotes and @.

Breaking and Continuing Loops: Controlling Flow

Sometimes you need to control the flow of a loop. Bash provides break and continue statements for this purpose.

  • break: Exits the loop entirely.
  • continue: Skips the rest of the current iteration and moves to the next one.
for i in 1 2 3 4 5; do
  if [ "$i" -eq 3 ]; then
    break  # Exit the loop if i is 3
  fi
  echo "Number: $i"
done

This script will output:

Number: 1
Number: 2

for i in 1 2 3 4 5; do
  if [ "$i" -eq 3 ]; then
    continue  # Skip the rest of the iteration if i is 3
  fi
  echo "Number: $i"
done

This script will output:

Number: 1
Number: 2
Number: 4
Number: 5

Practical Examples: Putting it all Together

Let’s look at a few practical examples to solidify your understanding.

Example 1: Creating Multiple Directories

for dir in dir1 dir2 dir3; do
  mkdir "$dir"
  echo "Created directory: $dir"
done

This script will create three directories: dir1, dir2, and dir3.

Example 2: Renaming Files (Batch Rename)

for file in *.txt; do
  new_name="${file%.txt}_backup.txt"  # Remove .txt and add _backup.txt
  mv "$file" "$new_name"
  echo "Renamed $file to $new_name"
done

This script renames all .txt files in the current directory, adding “_backup” to their names. The ${file%.txt} removes the “.txt” extension.

Debugging For Loops: Identifying and Fixing Errors

Debugging for loops is crucial. Common issues include:

  • Incorrect variable names: Double-check variable names for typos.
  • Incorrect loop conditions: Ensure the loop condition accurately reflects what you want to achieve.
  • Incorrect file paths: Verify that file paths are correct, especially when using wildcards.
  • Missing quotes: Always enclose variables in double quotes (e.g., "$file") to prevent word splitting and globbing issues.
  • Incorrect syntax: Make sure that your scripts use the correct syntax.

Use echo statements to print variable values and trace the execution of your loop. This helps you understand what’s happening at each step. Consider using set -x (at the beginning of your script) to enable shell debugging, which will print each command before it’s executed. Use set +x to disable it.

FAQs about Shell Script For Loops

Here are some frequently asked questions about shell script for loops:

What happens if the list in a for loop is empty?

If the list in a for loop is empty, the loop will not execute any of the commands within the do...done block. It will simply be skipped.

How can I loop through the lines of a file?

You can loop through the lines of a file using a while loop combined with the read command. However, this is often less efficient for simple iteration than processing the file’s contents using tools like awk or sed within the loop. For instance:

while IFS= read -r line; do
  echo "Line: $line"
done < "my_file.txt"

Why do I need to quote my variables?

Quoting variables, particularly when they contain spaces or special characters, prevents unexpected behavior. Without quotes, the shell might split the variable’s contents into multiple words, leading to errors or unintended results.

Can I nest multiple loops?

Yes, you can nest any number of for loops to create more complex processing logic. This is useful for working with multi-dimensional data or performing operations that require multiple levels of iteration.

How do I get the index of the current item in a for loop?

While the basic for loop doesn’t directly provide an index, you can achieve this by using a counter variable. Initialize the counter before the loop and increment it inside the loop. For example, with an array:

my_array=("apple" "banana" "cherry")
index=0
for element in "${my_array[@]}"; do
  echo "Index: $index, Fruit: $element"
  ((index++))  # Increment the index
done

Conclusion: Mastering the For Loop

The for loop is a cornerstone of shell scripting. By understanding the different syntax variations, from basic list iteration to C-style loops and array processing, you gain a powerful tool for automating repetitive tasks and streamlining your workflow. Remember to practice with various examples, experiment with different scenarios, and master debugging techniques. With consistent practice, you’ll be well on your way to becoming a proficient shell script writer. This guide provides a solid foundation for using for loops effectively in your shell scripts.