> ## 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 Until Loop
The Bash `until` loop is a control flow construct that repeatedly executes a block of commands as long as a specified condition evaluates to false (returns a non-zero exit status). It functions as the logical inverse of the `while` loop, terminating execution the moment the condition evaluates to true (returns an exit status of `0`).
## Syntax
The standard multi-line syntax for the `until` loop is:
```bash theme={"dark"}
until [ condition ]
do
# Commands to execute
done
```
For inline or single-line execution, semicolons are required to separate the structural keywords from the commands:
```bash theme={"dark"}
until [ condition ]; do commands; done
```
## Execution Mechanics
1. **Condition Evaluation:** Bash executes the command or test provided in the `condition` slot.
2. **Exit Status Check:** Bash inspects the exit status (`$?`) of that condition.
* If the exit status is **non-zero** (logical `false`), the commands inside the `do...done` block are executed.
* If the exit status is **zero** (logical `true`), the loop immediately terminates, and control flow passes to the next statement following the `done` keyword.
3. **Iteration:** After executing the `do...done` block, control returns to step 1.
## Condition Types
The `condition` is not limited to boolean expressions; it can be any valid Bash command. The loop's continuation depends strictly on the command's exit code.
**Using the `test` construct (`[[ ]]` or `[ ]`):**
This is the most common approach, evaluating arithmetic or string comparisons.
```bash theme={"dark"}
counter=0
until [[ $counter -eq 3 ]]; do
((counter++))
done
```
*Execution flow:* The loop runs while `$counter -eq 3` returns `1` (false). Once `$counter` reaches `3`, the test returns `0` (true), and the loop exits.
**Using standard commands:**
The loop can evaluate the success or failure of standard executables.
```bash theme={"dark"}
until command_that_might_fail; do
sleep 1
done
```
*Execution flow:* The loop body executes repeatedly as long as `command_that_might_fail` returns an exit code greater than `0`.
## Loop Control Statements
The `until` loop respects standard Bash loop control statements:
* **`break`**: Immediately terminates the loop entirely, regardless of the condition's current state.
* **`continue`**: Halts the current iteration, skipping any remaining commands in the `do...done` block, and immediately re-evaluates the condition for the next iteration.
## Infinite Loops
Because the `until` loop requires a `0` exit status to terminate, providing a command that permanently returns a non-zero exit status creates an infinite loop. The `false` command (which always exits with `1`) is the standard idiom for an infinite `until` loop:
```bash theme={"dark"}
until false; do
# This block will execute indefinitely
done
```
Tired of Poor Bash Skills? Fix That With Deep Grasping!
Learn More
