This article needs additional citations for verification. (October 2016) (Learn how and when to remove this template message) |

In most computer programming languages, a **while loop** is a control flow statement that allows code to be executed repeatedly based on a given Boolean condition. The *while* loop can be thought of as a repeating if statement.

## Overview

The *while* construct consists of a block of code and a condition/expression.^{[1]} The condition/expression is evaluated, and if the condition/expression is *true*,^{[1]} the code within all of their following in the block is executed. This repeats until the condition/expression becomes false. Because the *while* loop checks the condition/expression before the block is executed, the control structure is often also known as a **pre-test loop**. Compare this with the *do while* loop, which tests the condition/expression *after* the loop has executed.

For example, in the C programming language (as well as Java, C#,^{[2]} Objective-C, and C++, which use the same syntax in this case), the code fragment

```
int x = 0;
while (x < 5) {
printf ("x = %d\n", x);
x++;
}
```

first checks whether x is less than 5, which it is, so then the {loop body} is entered, where the *printf* function is run and x is incremented by 1. After completing all the statements in the loop body, the condition, (x < 5), is checked again, and the loop is executed again, this process repeating until the variable x has the value 5.

Note that it is possible, and in some cases desirable, for the condition to *always* evaluate to true, creating an infinite loop. When such a loop is created intentionally, there is usually another control structure (such as a break statement) that controls termination of the loop.
For example:

```
while (true) {
// do complicated stuff
if (someCondition)
break;
// more stuff
}
```

## Demonstrating *while* loops

These *while* loops will calculate the factorial of the number 5:

### ActionScript 3

```
var counter: int = 5;
var factorial: int = 1;
while (counter > 1) {
factorial *= counter;
counter--;
}
Printf("Factorial = %d", factorial);
```

### Ada

The Wikibook Ada_Programming has a page on the topic of: Control |

```
with Ada.Integer_Text_IO;
procedure Factorial is
Counter : Integer := 5;
Factorial : Integer := 1;
begin
while Counter > 0 loop
Factorial := Factorial * Counter;
Counter := Counter - 1;
end loop;
Ada.Integer_Text_IO.Put (Factorial);
end Factorial;
```

### AutoHotkey

```
counter := 5
factorial := 1
While counter > 0
factorial *= counter--
MsgBox % factorial
```

### Microsoft Small Basic

```
counter = 5 ' Counter = 5
factorial = 1 ' initial value of variable "factorial"
While counter > 0
factorial = factorial * counter
counter = counter - 1
TextWindow.WriteLine(counter)
EndWhile
```

### Visual Basic

```
Dim counter As Integer = 5 ' init variable and set value
Dim factorial As Integer = 1 ' initialize factorial variable
Do While counter > 0
factorial = factorial * counter
counter = counter - 1
Loop ' program goes here, until counter = 0
'Debug.Print factorial ' Console.WriteLine(factorial) in Visual Basic .NET
```

### Bourne (Unix) shell

```
counter=5
factorial=1
while [ $counter -gt 0 ]; do
factorial=$((factorial * counter))
counter=$((counter - 1))
done
echo $factorial
```

### C or C++

```
int main() {
int counter = 5;
int factorial = 1;
while (counter > 1)
factorial *= counter--;
printf("%d", factorial);
}
```

### CFML

#### Script syntax

```
counter = 5;
factorial = 1;
while (counter > 1) {
factorial *= counter--;
}
writeOutput(factorial);
```

#### Tag syntax

```
<cfset counter = 5>
<cfset factorial = 1>
<cfloop condition="counter GT 1">
<cfset factorial *= counter-->
</cfloop>
<cfoutput>#factorial#</cfoutput>
```

### Fortran

```
program FactorialProg
integer :: counter = 5
integer :: factorial = 1
do while (counter > 0)
factorial = factorial * counter
counter = counter - 1
end do
print *, factorial
end program FactorialProg
```

### Java, C#, D

The code for the loop is the same for Java, C# and D:

```
int counter = 5;
int factorial = 1;
while (counter > 1)
factorial *= counter--;
```

### JavaScript

```
let counter = 5;
let factorial = 1;
while (counter > 1)
factorial *= counter--;
console.log(factorial);
```

### Lua

```
counter = 5
factorial = 1
while counter > 0 do
factorial = factorial * counter
counter = counter - 1
end
print(factorial)
```

### MATLAB & GNU Octave

```
counter = 5;
factorial = 1;
while (counter > 0)
factorial = factorial * counter; %Multiply
counter = counter - 1; %Decrement
end
factorial
```

### Mathematica

```
Block[{counter=5,factorial=1}, (*localize counter and factorial*)
While[counter>0, (*While loop*)
factorial*=counter; (*Multiply*)
counter--; (*Decrement*)
];
factorial
]
```

### Oberon, Oberon-2 (programming language), Oberon-07, or Component Pascal

```
MODULE Factorial;
IMPORT Out;
VAR
Counter, Factorial: INTEGER;
BEGIN
Counter := 5;
Factorial := 1;
WHILE Counter > 0 DO
Factorial := Factorial * Counter;
DEC(Counter)
END;
Out.Int(Factorial,0)
END Factorial.
```

### Maya Embedded Language

```
int $counter = 5;
int $factorial = 1;
int $multiplication;
while ($counter > 0) {
$multiplication = $factorial * $counter;
$counter -= 1;
print("Counter is: " + $counter + ", multiplication is: " + $multiplication + "\n");
}
```

### Nim

```
var
counter = 5 # Set counter value to 5
factorial = 1 # Set factorial value to 1
while counter > 0: # While counter is greater than 0
factorial *= counter # Set new value of factorial to counter.
dec counter # Set the counter to counter - 1.
echo factorial
```

Non-terminating while loop:

```
while true:
echo "Help! I'm stuck in a loop!"
```

### Pascal

```
program Factorial1;
var
Counter, Factorial: integer;
begin
Counter := 5;
Factorial := 1;
while Counter > 0 do
begin
Factorial := Factorial * Counter;
Counter := Counter - 1
end;
WriteLn(Factorial)
end.
```

### Perl

```
my $counter = 5;
my $factorial = 1;
while ($counter > 0) {
$factorial *= $counter--; # Multiply, then decrement
}
print $factorial;
```

*While* loops are frequently used for reading data line by line (as defined by the `$/`

line separator) from open filehandles:

```
open IN, "<test.txt";
while (<IN>) {
print;
}
close IN;
```

### PHP

```
$counter = 5;
$factorial = 1;
while ($counter > 0) {
$factorial *= $counter--; // Multiply, then decrement.
}
echo $factorial;
```

### PL/I

```
declare counter fixed initial(5);
declare factorial fixed initial(1);
do while(counter > 0)
factorial = factorial * counter;
counter = counter - 1;
end;
```

### Python

```
counter = 5 # Set the value to 5
factorial = 1 # Set the value to 1
while counter > 0: # While counter(5) is greater than 0
factorial *= counter # Set new value of factorial to counter.
counter -= 1 # Set the counter to counter - 1.
print(factorial) # Print the value of factorial.
```

Non-terminating while loop:

```
while True:
print("Help! I'm stuck in a loop!")
```

### Racket

In Racket, as in other Scheme implementations, a *named-let* is a popular way to implement loops:

```
#lang racket
(define counter 5)
(define factorial 1)
(let loop ()
(when (> counter 0)
(set! factorial (* factorial counter))
(set! counter (sub1 counter))
(loop)))
(displayln factorial)
```

Using a macro system, implementing a *while* loop is a trivial exercise (commonly used to introduce macros):

```
#lang racket
(define-syntax-rule (while test body ...) ; implements a while loop
(let loop () (when test body ... (loop))))
(define counter 5)
(define factorial 1)
(while (> counter 0)
(set! factorial (* factorial counter))
(set! counter (sub1 counter)))
(displayln factorial)
```

But note that an imperative programming style is often discouraged in Racket (as in Scheme).

### Ruby

```
# Calculate the factorial of 5
i = 1
factorial = 1
while i <= 5
factorial *= i
i += 1
end
puts factorial
```

### Rust

```
fn main() {
let mut counter = 5;
let mut factorial = 1;
while counter > 1 {
factorial *= counter;
counter -= 1;
}
println!("{}", factorial);
}
```

### Smalltalk

Contrary to other languages, in Smalltalk a *while* loop is not a language construct but defined in the class `BlockClosure`

as a method with one parameter, the body as a closure, using self as the condition.

Smalltalk also has a corresponding whileFalse: method.

```
| count factorial |
count := 5.
factorial := 1.
[count > 0] whileTrue:
[factorial := factorial * count.
count := count - 1].
Transcript show: factorial
```

### Swift

```
var counter = 5 // Set the initial counter value to 5
var factorial = 1 // Set the initial factorial value to 1
while counter > 0 { // While counter(5) is greater than 0
factorial *= counter // Set new value of factorial to factorial x counter.
counter -= 1 // Set the new value of counter to counter - 1.
}
print(factorial) // Print the value of factorial.
```

### Tcl

```
set counter 5
set factorial 1
while {$counter > 0} {
set factorial [expr $factorial * $counter]
incr counter -1
}
puts $factorial
```

### VEX

```
int counter = 5;
int factorial = 1;
while (counter > 1)
factorial *= counter--;
printf("%d", factorial);
```

### PowerShell

```
$counter = 5
$factorial = 1
while ($counter) {
$factorial *= $counter--
}
$factorial
```

### While programming language

The While programming language^{[3]} is a simple programming language constructed from assignments, sequential composition, conditionals and while statements, used in the theoretical analysis of imperative programming language semantics.^{[4]}^{[5]}

```
C := 5;
F := 1;
while (C > 1) do
F := F * C;
C := C - 1;
```

## See also

- Do while loop
- For loop
- Foreach
- LOOP (programming language) – a programming language with the property that the functions it can compute are exactly the primitive recursive functions

## References

- ^
^{a}^{b}"The while and do-while Statements (The Java™ Tutorials > Learning the Java Language > Language Basics)".*Dosc.oracle.com*. Retrieved 2016-10-21. **^**"while (C# reference)".*Msdn.microsoft.com*. Retrieved 2016-10-21.**^**"Chapter 3 : The While programming language" (PDF).*Profs.sci.univr.it*. Retrieved 2016-10-21.**^**Flemming Nielson; Hanne R. Nielson; Chris Hankin (1999).*Principles of Program Analysis*. Springer. ISBN 978-3-540-65410-0. Retrieved 29 May 2013.**^**Illingworth, Valerie (11 December 1997).*Dictionary of Computing*. Oxford Paperback Reference (4th ed.). Oxford University Press. ISBN 9780192800466.