Comprehensive Guide to Variable-Based Number Iteration in Bash

Introduction

In Bash script programming, loop structures are fundamental tools for implementing automation and batch processing. Among these, the for loop stands out for its simplicity and flexibility, making it widely applicable across various scenarios. However, when iteration needs to be based on numerically defined ranges through variables, many developers encounter syntactic challenges. This paper begins with basic concepts and progressively delves into multiple solutions for handling variable-based range iteration in Bash.

Bash Loop Fundamentals and Variable Range Challenges

Bash provides multiple loop structures, with the for loop being the most commonly used iteration tool. Basic number range iteration can be achieved using sequence expressions (Brace Expansion):

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

This code sequentially outputs numbers 1 through 5, each on a separate line. The sequence expression syntax is concise and clear, but in practical programming, we often need to determine iteration ranges based on runtime variable values. When attempting to replace endpoints with variables:

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

The result outputs the literal string "{1..5}" instead of the expected numerical sequence. This occurs because Brace Expansion is parsed before variable expansion, preventing variables from being correctly recognized as numerical endpoints.

Solution Using the seq Command

To address this issue, the most direct and effective solution involves using the seq command. seq is a standard utility in Linux systems specifically designed for generating numerical sequences, perfectly handling variable-defined ranges:

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

In this implementation, seq 1 $END generates an integer sequence from 1 to the END value, with command substitution $(...) providing this sequence as a list to the for loop. This approach offers several advantages: intuitive and memorable syntax, excellent compatibility, support for floating-point sequences, and the ability to specify step sizes. For example, generating odd numbers from 1 to 10:

for i in $(seq 1 2 10); do
    echo $i
done

Although seq is not a Bash built-in command, it comes pre-installed in most Linux distributions, ensuring the solution's general applicability.

Bash Built-in Arithmetic For Loop

Beyond relying on external commands, Bash provides a built-in arithmetic for loop, whose syntax is inspired by C language, capable of directly handling variable operations:

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

This writing style features clear structure: the initialization expression i=1 sets the starting value, the condition expression i<=END defines the loop continuation condition, and the step expression i++ controls the increment per iteration. Due to the use of double parentheses ((...)), Bash automatically performs arithmetic evaluation, and the variable END does not require a dollar sign prefix.

The arithmetic for loop's advantage lies in its complete reliance on Bash built-in functionality, independence from external commands, and higher execution efficiency. Additionally, it supports more complex loop control, including decremental iteration and custom step sizes:

START=5
END=1
for ((i=START; i>=END; i--)); do
    echo $i
done

Analysis of Practical Application Scenarios

Batch File Processing

In system administration tasks, file processing based on numerical sequences is frequently required. Suppose backups need to be created for multiple log files:

FILE_COUNT=10
for i in $(seq 1 $FILE_COUNT); do
    cp "log$i.txt" "backup/log$i.bak"
done

The same functionality can be achieved using the arithmetic for loop:

FILE_COUNT=10
for ((i=1; i<=FILE_COUNT; i++)); do
    cp "log$i.txt" "backup/log$i.bak"
done

File Change Detection in CI/CD Pipelines

In continuous integration environments, there's often a need to perform specific operations only on changed files. Combining git commands to obtain file lists:

CHANGED_FILES=$(git diff-tree --no-commit-id --name-only -r $COMMIT_HASH)
for file in $CHANGED_FILES; do
    if [[ "$file" == *.yaml ]]; then
        yamllint "$file"
    fi
done

This pattern is extremely practical in automated testing and code quality checks, significantly improving CI/CD pipeline execution efficiency.

System User Management

System administrators often need to perform batch operations on user accounts, where numerical iteration is quite common:

USER_COUNT=50
for ((i=1; i<=USER_COUNT; i++)); do
    username="user$i"
    if id "$username" &>/dev/null; then
        usermod -s /bin/bash "$username"
    fi
done

Performance and Compatibility Considerations

When selecting an iteration solution, execution efficiency and environmental compatibility must be comprehensively considered. The seq command approach, while syntactically simple, involves external process creation and may incur performance overhead during extensive iterations. The arithmetic for loop, as a Bash built-in feature, offers higher execution efficiency but requires Bash version support.

For scenarios involving large data processing, benchmark testing is recommended. Here's a simple performance comparison example:

# Testing seq command performance
time for i in $(seq 1 10000); do :; done

# Testing arithmetic for loop performance
time for ((i=1; i<=10000; i++)); do :; done

In actual deployment, the target environment's Bash version and available tools must also be considered to ensure script cross-platform compatibility.

Best Practice Recommendations

Based on in-depth analysis of various solutions, we propose the following practical recommendations: For simple numerical sequence iteration, prioritize the arithmetic for loop due to its optimal performance and clear syntax. When generating complex sequences (such as floating-point numbers or specific step sizes), the seq command offers better flexibility. When writing production environment scripts, appropriate error handling should be added:

END=${1:-10}  # Use parameter or default value
if ! [[ "$END" =~ ^[0-9]+$ ]]; then
    echo "Error: Please enter a valid number" >&2
    exit 1
fi

for ((i=1; i<=END; i++)); do
    echo "Processing item $i"
done

Conclusion

Bash provides multiple methods for handling variable-based range iteration, each with its applicable scenarios. The seq command, with its intuitive syntax, serves as an ideal choice for beginners, while the arithmetic for loop offers a better option for advanced users seeking performance and conciseness. Understanding these tools' working principles and applicable conditions enables developers to select the most suitable solution based on specific requirements, writing efficient and robust Bash scripts.

In practical development, it is advised to choose the appropriate iteration method by combining specific use cases, performance requirements, and environmental constraints. By mastering these core concepts and technical details, developers can more freely utilize Bash scripts to solve various automation and batch processing tasks.