How to Iterate Over a Range of Numbers Defined by Variables in Bash

When working with Bash, iterating over a range of numbers is common in scripting. One might naturally reach for brace expansion (e.g., {1..5}) when the range is hardcoded, but things get a bit trickier when the range is defined by variables. In this blog post, we’ll explore different ways to iterate over a range of numbers when the endpoints are determined by variables.

The Problem

Typically, in Bash, you can iterate over a fixed range using brace expansion, like this:

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

This produces the expected output:

1
2
3
4
5

However, when you try to replace either of the range endpoints with a variable, such as:

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

The script will not work as expected. Instead of interpreting the variable $END, Bash treats it literally, printing:

{1..5}

This happens because brace expansion occurs before variable expansion in Bash, meaning that the braces are processed as literal text before the shell substitutes the variable values.

Solutions

To solve this problem, there are multiple approaches, each with its own pros and cons. Let’s look at the most common ones.

1. Using seq

One of the simplest ways to iterate over a range defined by variables is to use the seq command, which generates a sequence of numbers:

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

This will output:

1
2
3
4
5

The seq command is straightforward and easy to remember. However, it spawns a separate process to execute, which can introduce a performance overhead for very large ranges.

2. Using C-style for Loops

Bash also supports a C-style for loop, which can be used to iterate over a range of numbers:

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

This will produce the same output as before:

1
2
3
4
5

In this case, no external commands are needed, and everything runs within Bash itself. This makes it more efficient for larger loops compared to seq.

3. Using eval and Brace Expansion

Another approach is to use eval with brace expansion. This method evaluates the range expression dynamically, allowing the variable to be expanded correctly:

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

Again, the output is as expected:

1
2
3
4
5

While this works, using eval can be dangerous, especially when working with untrusted input, as it can lead to security vulnerabilities like code injection.

4. Using a while Loop

A while loop can also achieve the same result by manually incrementing a counter:

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

The output:

1
2
3
4
5

This method is more flexible, and no external commands are invoked, making it lightweight. It’s a good alternative if you prefer not to use for loops.

Performance Considerations

• seq: Easy to use but spawns a new process, which can be slower when iterating over large ranges.
• C-style for loops: Efficient and keeps everything within Bash, making it preferable for performance.
• eval with brace expansion: Works well but should be used cautiously due to potential security risks.
• while loop: Offers more control and flexibility, but might be less concise than the other options.

When iterating over a range of numbers defined by variables in Bash, there are several methods to choose from. The seq command is simple and widely used, while C-style for loops and while loops are more efficient and avoid external processes. For those willing to use eval, brace expansion can also work, but it’s important to be cautious with this approach.