Looping with Numeric Ranges in Bash

Bash scripting often requires iterating over a sequence of numbers. While Bash provides several ways to achieve this, understanding the nuances of each approach is crucial for writing robust and portable scripts. This tutorial will explore common methods for looping through numeric ranges in Bash, focusing on clarity, efficiency, and best practices.

Basic Looping with `for` and Brace Expansion

Bash offers a convenient way to iterate over a simple range of numbers using brace expansion within a for loop. The syntax for i in {start..end} creates a list of numbers from start to end, and the loop iterates through each number in the list.

for i in {1..5}; do
  echo $i
done

This script will output:

However, this method has a limitation: it only works with literal numbers. You cannot directly substitute variables into the brace expansion. For example, the following will not work as expected:

END=5
for i in {1..$END}; do
  echo $i
done

This will output {1..5} instead of the expected sequence, because brace expansion happens before variable substitution.

Using `seq` for Variable Ranges

To iterate over a range defined by variables, the seq command provides a reliable solution. seq generates a sequence of numbers, starting from a specified value, incrementing by a specified amount, and ending at a specified value.

END=5
for i in $(seq 1 $END); do
  echo $i
done

This script will produce the same output as the first example:

The seq command allows for more flexible range definitions:

seq start increment end: Specify a starting value, an increment, and an ending value. For example, seq 2 2 10 would output 2 4 6 8 10.

While seq is convenient, it’s an external command. Calling external commands within a loop can be less efficient than using Bash’s built-in features. Also, seq is not a POSIX standard command, limiting script portability.

Utilizing Arithmetic Expansion within `for` Loops

Bash provides an arithmetic expansion construct that allows you to perform calculations directly within the script. You can leverage this construct to create a loop that iterates over a variable range without relying on external commands.

END=5
for ((i=1; i<=END; i++)); do
  echo $i
done

This code snippet achieves the same result as the previous examples. The ((...)) construct performs arithmetic evaluation, and the loop continues as long as i is less than or equal to END, incrementing i by 1 in each iteration. This method is generally more efficient than using seq and doesn’t rely on external programs.

Ensuring Portability with POSIX-Compliant Loops

For maximum script portability, it’s best to adhere to the POSIX standard as much as possible. Here’s a POSIX-compliant loop that iterates over a numeric range:

END=5
i=1
while [ $i -le $END ]; do
  echo $i
  i=$((i+1))
done

This approach uses a while loop and explicitly increments the counter variable i. While slightly more verbose, it’s guaranteed to work on any POSIX-compliant shell.

Considerations for Large Ranges

When dealing with very large ranges, the memory usage of creating a list of numbers (as seq and brace expansion can do implicitly) can become a concern. In such scenarios, the while loop or the arithmetic for loop are preferred because they don’t require storing the entire sequence in memory.

Best Practices

Portability: If your script needs to run on various systems, prioritize POSIX-compliant solutions like the while loop.
Efficiency: For simple numeric ranges, the arithmetic for loop is often the most efficient. Avoid unnecessary external command calls.
Memory Usage: When dealing with large ranges, favor methods that don’t store the entire sequence in memory.
Readability: Choose the method that best conveys your intent and makes your script easy to understand.