> ## 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.
# TypeScript Do-While Loop
A `do-while` loop in TypeScript is a post-test control flow structure that executes a specified block of code at least once before evaluating a boolean condition to determine whether the iteration should continue. Because the condition is evaluated at the end of the loop's body, the execution context is guaranteed to run the initial iteration regardless of the condition's initial truth value.
## Syntax
```typescript theme={"dark"}
do {
// Statement(s) to execute
} while (condition);
```
## Execution Mechanics
1. **Initial Execution:** The statement block within the `do` clause is executed immediately upon entering the loop structure.
2. **Condition Evaluation:** The `condition` expression within the `while` clause is evaluated.
3. **Iteration:** If the `condition` evaluates to a truthy value, the control flow jumps back to the beginning of the `do` block.
4. **Termination:** If the `condition` evaluates to a falsy value, the loop terminates, and the execution context proceeds to the next statement following the loop.
## Technical Characteristics
* **Type Evaluation and Narrowing:** TypeScript expects the `condition` to be an expression that can be evaluated as a boolean. Because a `do-while` loop evaluates its condition at the *end* of the iteration, the condition cannot narrow types for the first execution of the loop body. Any type narrowing provided by the `while` condition (such as a type guard) only applies to the code executing *after* the loop terminates, where the compiler knows the condition has evaluated to false.
* **Variable Scoping:** Variables declared with `let` or `const` inside the `do` block are block-scoped and cannot be accessed within the `while` condition. The condition can only reference variables declared in an outer scope.
* **Control Modifiers:**
* `break`: Immediately terminates the loop entirely, bypassing the `while` condition check.
* `continue`: Skips the remaining statements in the current iteration's `do` block and immediately jumps to the `while` condition evaluation.
## Code Visualization
```typescript theme={"dark"}
let iterationCount: number = 0;
do {
iterationCount++;
// Control flow guarantees this block executes before the condition is ever checked.
} while (iterationCount < 0);
console.log(iterationCount); // Output: 1
```
In the example above, despite the condition `iterationCount < 0` being mathematically false at the time of evaluation, the post-test nature of the loop ensures the block executes exactly once before termination.
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
