> ## 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.
# JavaScript Do-While Loop
A `do...while` statement creates a loop that executes a specified statement until the test condition evaluates to false. Because the condition is evaluated after the execution of the statement, the loop's payload is guaranteed to execute at least once, making it a post-test control flow mechanism.
## Syntax
```javascript theme={"dark"}
do
statement
while (condition);
```
* **`statement`:** The code executed on each iteration. This can be a single statement (e.g., `do count++; while (count < 5);`) or, more commonly, a block statement (`{ ... }`) grouping multiple statements.
* **`condition`:** An expression evaluated after each pass through the loop. JavaScript applies type coercion, evaluating the expression for truthiness or falsiness.
* **Semicolon (`;`):** Terminating the `do...while` statement with a semicolon is standard best practice. However, if omitted, JavaScript's Automatic Semicolon Insertion (ASI) rules will automatically insert a semicolon after the closing parenthesis of the `while` condition.
## Execution Flow
1. The JavaScript engine executes the `statement` associated with the `do` clause.
2. The engine evaluates the `condition` inside the `while` clause.
3. If the condition is truthy, control flow jumps back to step 1.
4. If the condition is falsy, the loop terminates and control passes to the next statement in the program.
## Code Examples
**Block Statement Execution**
The standard approach uses a block statement to execute multiple lines of code per iteration.
```javascript theme={"dark"}
let iteration = 0;
do {
console.log(`Iteration: ${iteration}`);
iteration++;
} while (iteration < 3);
// Output:
// Iteration: 0
// Iteration: 1
// Iteration: 2
```
**Single Statement Execution**
If only one operation is required, the block braces can be omitted.
```javascript theme={"dark"}
let count = 0;
do count++; while (count < 3);
console.log(count); // Output: 3
```
**Falsy Initial Condition**
Even if the condition is strictly `false` at the time of initial evaluation, the statement executes exactly once before termination.
```javascript theme={"dark"}
let flag = false;
do {
console.log("This executes unconditionally on the first pass.");
} while (flag === true);
// Output:
// This executes unconditionally on the first pass.
```
## Technical Considerations
* **Variable Scope:** Variables declared with `let` or `const` inside a `do` block statement are block-scoped. They are destroyed at the end of the block and cannot be accessed within the `while` condition. Variables evaluated in the condition must be declared in an outer, enclosing scope.
* **Infinite Loops:** As with any indefinite loop, failing to mutate the variables evaluated in the `condition` (or failing to use a `break` statement) will result in an infinite loop, blocking the main thread.
Tired of Poor JavaScript Skills? Fix That With Deep Grasping!
Learn More
