> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Bash Arithmetic For Loop
The Bash arithmetic `for` loop, commonly referred to as the C-style `for` loop, is a control flow statement that utilizes Bash's arithmetic evaluation context `(( ))` to iterate based on numerical expressions. It evaluates three distinct arithmetic expressions to control initialization, loop continuation, and iteration stepping.
```bash theme={"dark"}
for (( expr1; expr2; expr3 )); do
# statements
done
```
## Component Breakdown
* **`expr1` (Initialization)**: An arithmetic expression evaluated exactly once before the loop begins. While typically used to initialize loop control variables, Bash does not enforce this syntactically or semantically. It can contain any valid arithmetic operation, discard its result, or be omitted entirely.
* **`expr2` (Condition)**: Evaluated before each iteration. If the arithmetic evaluation yields a non-zero value (true), the loop body executes. If it evaluates to `0` (false), the loop terminates. If omitted, it defaults to `1` (creating an infinite loop).
* **`expr3` (Step)**: Evaluated at the end of each iteration, immediately after the loop body executes. It is typically used to mutate loop control variables (e.g., incrementing or decrementing).
## Execution Context and Rules
Because the loop parameters are enclosed in double parentheses `(( ))`, they are parsed under Bash's **arithmetic evaluation** rules (as an arithmetic compound command), rather than standard shell word splitting or globbing rules. This is distinct from *arithmetic expansion* (`$(( ))`), which substitutes the evaluated result back into the command line.
* **Variable Dereferencing**: Variables inside the arithmetic evaluation context do not require the `$` prefix for parameter expansion. Using `i < limit` is syntactically valid and safer than `$i < $limit`. If `limit` is unset or empty, `(( i < limit ))` safely evaluates as `(( 0 < 0 ))`. Conversely, `(( i < $limit ))` expands the variable *before* evaluation, resulting in a syntax error (`(( 0 < ))` throws `operand expected`).
* **Supported Operators**: The context supports standard C-style mathematical and relational operators, including pre/post-increment (`++i`, `i++`), pre/post-decrement (`--i`, `i--`), compound assignment (`+=`, `-=`, `*=`), and bitwise operations.
* **Comma Operator**: Multiple expressions can be evaluated within a single component (`expr1`, `expr2`, or `expr3`) by separating them with a comma `,`. When used in the `condition` (`expr2`), the expressions are evaluated from left to right, and the right-most expression determines the final truth value of the condition.
## Syntax Visualizations
**Standard Iteration:**
```bash theme={"dark"}
for (( i = 0; i < 10; i++ )); do
echo "$i"
done
```
**Multiple Variables and Comma Operator in Condition:**
```bash theme={"dark"}
for (( i = 0, j = 100; i <= 50, j > 0; i++, j -= 2 )); do
# The loop continues as long as j > 0 is true,
# regardless of the evaluation of i <= 50.
echo "i: $i, j: $j"
done
```
**Omitted Expressions (Infinite Loop):**
```bash theme={"dark"}
for (( ; ; )); do
# Requires an internal break statement to terminate
break
done
```
**Dynamic Condition Evaluation:**
```bash theme={"dark"}
limit=5
for (( i = 1; i <= limit * 2; i += 2 )); do
echo "$i"
done
```
Tired of Poor Bash Skills? Fix That With Deep Grasping!
Learn More
