View source for While loop

{{Short description |Control flow statement for repeating execution until a condition is met}}
{{merge|target=Loop (statement)|For loop|Do while loop| discuss=Talk:While loop#Merge proposal|date=September 2025}}
[[File:While-loop-diagram.svg|thumb|right|While loop flow diagram]]
{{Loop constructs}}<!-- DO NOT remove. Discuss navigation concept at Talk:Do while loop#Helpbox experiment -->

In [[Computer programming|computer programming]], a '''while loop''' is a [[Control flow|control flow]] [[Statement (computer science)|statement]] that allows code to be executed repeatedly based on a [[Boolean data type|Boolean]] condition. The while loop can be thought of as a repeating [[Conditional (computer programming)|if statement]].

==Overview==
A while consists of a block of code and a conditional expression.<ref name=":0">{{cite web|url=http://docs.oracle.com/javase/tutorial/java/nutsandbolts/while.html|title=The while and do-while Statements (The Java Tutorials > Learning the Java Language > Language Basics)|website=Dosc.oracle.com|access-date=2016-10-21}}</ref> The conditional is evaluated, and if true,<ref name=":0" /> the block of code is executed. This repeats until the conditional becomes [[Philosophy:False (logic)|false]]. Because the while loop checks the conditional before the block is executed, the control structure is also known as a ''pre-test loop''. In contrast, [[Do while loop|do-while loop]] tests the conditional ''after'' the block.

For example, in the languages [[C (programming language)|C]], [[Java (programming language)|Java]], [[C Sharp (programming language)|C#]],<ref>{{cite web |url=http://msdn.microsoft.com/en-us/library/2aeyhxcd.aspx |title=while (C# reference)|website=Msdn.microsoft.com|access-date=2016-10-21}}</ref> [[Objective-C]], and [[C++]], (which [[Polyglot (computing)|use the same syntax]] in this case), the code fragment

<syntaxhighlight lang="c">
int x = 0;
while (x < 5) {
    printf ("x = %d\n", x);
    x++;
}
</syntaxhighlight>

first checks whether x is less than 5, which it is, so the loop body is entered, where {{code |printf()}} is called and x is incremented by 1. After completing the statements in the loop body, the condition, (x < 5), is checked again, and the loop is executed again. This process repeats until x has the value 5.

The condition can always valuate as true to create an [[Infinite loop|infinite loop]]. In this case, there may be a early-exit control structure (such as a [[Control flow|break]] statement) that controls termination of the loop. For example:

<syntaxhighlight lang="c">
while (true) {
    // do complicated stuff
    if (someCondition)
        break;
    // more stuff
}
</syntaxhighlight>

==Examples==
These while loops calculate the [[Factorial|factorial]] of 5:

===ActionScript 3===
<syntaxhighlight lang="actionscript">
var counter: int = 5;
var factorial: int = 1;

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

Printf("Factorial = %d", factorial);
</syntaxhighlight>

===Ada===
{{Wikibooks|Ada_Programming|Control}}
<syntaxhighlight lang="ada">
with Ada.Integer_Text_IO;

procedure Factorial is
    Counter   : Integer := 5;
    Factorial : Integer := 1;
begin
    while Counter > 1 loop
        Factorial := Factorial * Counter;
        Counter   := Counter - 1;
    end loop;

    Ada.Integer_Text_IO.Put (Factorial);
end Factorial;
</syntaxhighlight>

===APL===
<syntaxhighlight lang="apl">
counter ← 5
factorial ← 1

:While counter > 1
    factorial ×← counter
    counter -← 1
:EndWhile

⎕ ← factorial
</syntaxhighlight>

or simply
<syntaxhighlight lang="apl">
!5
</syntaxhighlight>

===AutoHotkey===
 <syntaxhighlight lang="autohotkey">
counter := 5
factorial := 1

While counter > 1
    factorial *= counter--

MsgBox % factorial
</syntaxhighlight>

===Small Basic===
<syntaxhighlight lang="vbnet">
counter = 5    ' Counter = 5
factorial = 1  ' initial value of variable "factorial"

While counter > 1
    factorial = factorial * counter
    counter = counter - 1
EndWhile

TextWindow.WriteLine("Factorial = " + factorial)
</syntaxhighlight>

===Visual Basic===
<syntaxhighlight lang="vbnet">
Dim counter As Integer = 5    ' init variable and set value
Dim factorial As Integer = 1  ' initialize factorial variable

Do While counter > 1
    factorial = factorial * counter
    counter = counter - 1
Loop     ' program goes here, until counter = 0

'Debug.Print factorial         ' Console.WriteLine(factorial) in Visual Basic .NET
</syntaxhighlight>

===Bourne (Unix) shell===
 <syntaxhighlight lang="bash">
counter=5
factorial=1
while [ $counter -gt 1 ]; do
    factorial=$((factorial * counter))
    counter=$((counter - 1))
done

echo $factorial
</syntaxhighlight>

===C, C++===
<syntaxhighlight lang="c">
int main() {
    int counter = 5;
    int factorial = 1;

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

    printf("%d", factorial);
}
</syntaxhighlight>

===ColdFusion Markup Language (CFML)===

====Script syntax====
<syntaxhighlight lang="cfs">
counter = 5;
factorial = 1;

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

writeOutput(factorial);
</syntaxhighlight>

====Tag syntax====
<syntaxhighlight lang=CFM>
<cfset counter = 5>
<cfset factorial = 1>
<cfloop condition="counter GT 1">
    <cfset factorial *= counter-->
</cfloop>
<cfoutput>#factorial#</cfoutput>
</syntaxhighlight>

===Fortran===
<syntaxhighlight lang="fortran">
program FactorialProg
    integer :: counter = 5
    integer :: factorial = 1

    do while (counter > 1)
        factorial = factorial * counter
        counter = counter - 1
    end do

    print *, factorial
end program FactorialProg
</syntaxhighlight>

===Go===
Go has no while statement, but it has the function of a for statement when omitting some elements of the for statement.

<syntaxhighlight lang="go">
counter, factorial := 5, 1

for counter > 1 {
	counter, factorial = counter-1, factorial*counter
}
</syntaxhighlight>

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

<syntaxhighlight lang="csharp">
int counter = 5;
int factorial = 1;

while (counter > 1) {
    factorial *= counter--;
}
</syntaxhighlight>

===JavaScript===
<syntaxhighlight lang="javascript">
let counter = 5;
let factorial = 1;

while (counter > 1)
    factorial *= counter--;

console.log(factorial);
</syntaxhighlight>

=== Kotlin ===
{{Main|Kotlin (programming language)}}
Source:<ref>{{cite web |title=Conditions and loops {{!}} Kotlin |url=https://kotlinlang.org/docs/control-flow.html#while-loops |website=Kotlin Help |access-date=21 October 2025}}</ref>
<syntaxhighlight lang="kotlin">
var counter = 5
var factorial = 1

while (counter > 1) {
    factorial = factorial * counter
    counter = counter - 1
}

println(factorial)
</syntaxhighlight>

===Lua===
<syntaxhighlight lang="lua">
counter = 5
factorial = 1

while counter > 1 do
  factorial = factorial * counter
  counter = counter - 1
end

print(factorial)
</syntaxhighlight>

===MATLAB, Octave===
 <syntaxhighlight lang="matlab">
counter = 5;
factorial = 1;

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

factorial
</syntaxhighlight>

===Mathematica===
 <syntaxhighlight lang="mathematica">
Block[{counter=5,factorial=1},  (*localize counter and factorial*)
    While[counter>1,            (*While loop*)
        factorial*=counter;     (*Multiply*)
        counter--;              (*Decrement*)
    ];

    factorial
]
</syntaxhighlight>

===Oberon, Oberon-2, Oberon-07, Component Pascal===
<syntaxhighlight lang="cp">
MODULE Factorial;
IMPORT Out;
VAR
    Counter, Factorial: INTEGER;
BEGIN
    Counter := 5;
    Factorial := 1;

    WHILE Counter > 1 DO
        Factorial := Factorial * Counter;
        DEC(Counter)
    END;

    Out.Int(Factorial,0)
END Factorial.
</syntaxhighlight>

===Maya Embedded Language===
<syntaxhighlight lang="perl">
int $counter = 5;
int $factorial = 1;

while ($counter > 1) {
    $factorial *= $counter;
    $counter -= 1;
}

print("Factorial = " + $factorial + "\n");
</syntaxhighlight>

===Nim===
<syntaxhighlight lang="nim">
var
  counter = 5            # Set counter value to 5
  factorial = 1          # Set factorial value to 1

while counter > 1:       # 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
</syntaxhighlight>

Non-terminating while loop:

<syntaxhighlight lang="nim">
while true:
  echo "Help! I'm stuck in a loop!"
</syntaxhighlight>

===Pascal===
Pascal has two forms of the while loop, {{code| while}} and {{code| repeat-until}}. {{code| while}} repeats one statement (unless enclosed in a begin-end block) as long as the condition is true. {{code| repeat-until}} repetitively executes a block of one or more statements until the a condition is false. The main difference between the two is that {{code| while}} executes zero times if the condition is initially false, whereas {{code| repeat-until}} executes at least once.

<syntaxhighlight lang="pascal">
program Factorial1;
var
    Fv: integer;

    procedure fact(counter:integer);
    var
        Factorial: integer;

    begin
         Factorial := 1;

         while Counter > 1 do
         begin
             Factorial := Factorial * Counter;
             Counter := Counter - 1
         end;

         WriteLn(Factorial)
     end;

begin
    Write('Enter a number to return its factorial: ');
    readln(fv);
    repeat
         fact(fv);
         Write('Enter another number to return its factorial (or 0 to quit): ');
     until fv=0;
end.
</syntaxhighlight>

===Perl===
<syntaxhighlight lang="perl">
my $counter   = 5;
my $factorial = 1;

while ($counter > 1) {
    $factorial *= $counter--; # Multiply, then decrement
}

print $factorial;
</syntaxhighlight>

''While'' loops are frequently used for reading data line by line (as defined by the <code>$/</code> line separator) from open filehandles:

<syntaxhighlight lang="perl">
open IN, "<test.txt";

while (<IN>) {
    print;
}

close IN;
</syntaxhighlight>

===PHP===
 <syntaxhighlight lang="php">
$counter = 5;
$factorial = 1;

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

echo $factorial;
</syntaxhighlight>

===PL/I===
The PL/I <code>DO</code> statement can act as either a [[For loop|for loop]], a while loop, or a do until loop.
<syntaxhighlight lang="rexx">
declare counter   fixed initial(5);
declare factorial fixed initial(1);

do while(counter > 1)
    factorial = factorial * counter;
    counter = counter - 1;
end;
</syntaxhighlight>

===Python===
<syntaxhighlight lang="python">
counter = 5                           # Set the value to 5
factorial = 1                         # Set the value to 1

while counter > 1:                    # 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.
</syntaxhighlight>

Non-terminating while loop:

<syntaxhighlight lang="python">
while True:
    print("Help! I'm stuck in a loop!")
</syntaxhighlight>

===Racket===
In Racket, as in other [[Scheme (programming language)|Scheme]] implementations, a ''named-let'' is a popular way to implement loops:
<syntaxhighlight lang="racket">
#lang racket
(define counter 5)
(define factorial 1)
(let loop ()
    (when (> counter 1)
        (set! factorial (* factorial counter))
        (set! counter (sub1 counter))
        (loop)))
(displayln factorial)
</syntaxhighlight>
Using a macro system, implementing a ''while'' loop is a trivial exercise (commonly used to introduce macros):
<syntaxhighlight lang="racket">
#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 1)
    (set! factorial (* factorial counter))
    (set! counter (sub1 counter)))
(displayln factorial)
</syntaxhighlight>
However, an imperative programming style is often discouraged in Scheme and Racket.

===Ruby===
<div style="width:48%; float:left; margin-right:2%;">
<syntaxhighlight lang="ruby">
# Count Down Variant
counter = 5
factorial = 1

while counter > 1
  factorial *= counter
  counter -= 1
end

puts factorial
</syntaxhighlight>
</div>

<div style="width:48%; float:left;">
<syntaxhighlight lang="ruby">
# Count Up Variant
counter = 2
factorial = 1

while counter <= 5
  factorial *= counter
  counter += 1
end

puts factorial
</syntaxhighlight>
</div>

<div style="clear:both;"></div>

===Rust===
<syntaxhighlight lang="rust">
fn main() {
    let mut counter = 5;
    let mut factorial = 1;

    while counter > 1 {
        factorial *= counter;
        counter -= 1;
    }

    println!("{}", factorial);
}
</syntaxhighlight>

===Smalltalk===
Contrary to other languages, in Smalltalk a ''while'' loop is not a [[Language construct|language construct]] but defined in the class <code>BlockClosure</code> as a method with one parameter, the body as a [[Closure (computer programming)|closure]], using self as the condition.

Smalltalk also has a corresponding whileFalse: method.

<syntaxhighlight lang="smalltalk">
| count factorial |
count := 5.
factorial := 1.
[count > 0] whileTrue:
    [factorial := factorial * count.
    count := count - 1].
Transcript show: factorial
</syntaxhighlight>

===Swift===
<syntaxhighlight lang="swift">
var counter = 5                 // Set the initial counter value to 5
var factorial = 1               // Set the initial factorial value to 1

while counter > 1 {             // 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.
</syntaxhighlight>

===Tcl===
<syntaxhighlight lang="tcl">
set counter 5
set factorial 1

while {$counter > 1} {
    set factorial [expr $factorial * $counter]
    incr counter -1
}

puts $factorial
</syntaxhighlight>

===PowerShell===
<syntaxhighlight lang="powershell">
$counter = 5
$factorial = 1

while ($counter) {
    $factorial *= $counter--
}

$factorial
</syntaxhighlight>

===While (language)===
While<ref>{{cite web|url=http://profs.sci.univr.it/~merro/files/WhileExtra_l.pdf |title=Chapter 3: The While programming language |website=Profs.sci.univr.it |access-date=2016-10-21}}</ref> is a simple programming language constructed from assignments, sequential composition, conditionals, and while statements, used in the theoretical analysis of imperative programming language [[Semantics (computer science)|semantics]].<ref name="NielsonNielson1999">{{cite book|author1=Flemming Nielson|author2=Hanne R. Nielson|author3=Chris Hankin|title=Principles of Program Analysis|url=https://books.google.com/books?id=RLjt0xSj8DcC|access-date=29 May 2013|year=1999|publisher=Springer|isbn=978-3-540-65410-0}}</ref><ref>{{cite book |first=Valerie |last=Illingworth |date=11 December 1997 |title=Dictionary of Computing |edition=4th |series=Oxford Paperback Reference |publisher=Oxford University Press |isbn=9780192800466 |url-access=registration |url=https://archive.org/details/dictionaryofcomp00illi}}</ref>
<syntaxhighlight lang="whiley">
C := 5;
F := 1;

while (C > 1) do
    F := F * C;
    C := C - 1;
</syntaxhighlight>

==See also==
* [[Do while loop]]
* [[For loop]]
* Foreach
* [[Primitive recursive function]]
* [[General recursive function]]
* [[LOOP (programming language)]] – a programming language with the property that the functions it can compute are exactly the primitive recursive functions

==References==
{{Reflist}}

{{DEFAULTSORT:While Loop}}
[[Category:Control flow]]
[[Category:Iteration in programming]]
[[Category:Programming language comparisons]]
<!-- Hidden categories below -->
[[Category:Articles with example C code]]
[[Category:Articles with example C Sharp code]]

{{Sourceattribution|While loop}}