imported>FaviFake: update merge notice

2025-10-26T21:34:55Z

update merge notice

New page

{{Short description |Control flow statement for repeating execution until a condition is met}}
{{use dmy dates|date=September 2025}}
{{merge|target=Loop (statement)|For loop|Do while loop| discuss=Talk:While loop#Merge proposal|date=September 2025}}
{{Refimprove|date=October 2016}}
[[File:While-loop-diagram.svg|thumb|right|While loop flow diagram]]
{{Loop constructs}}

In [[computer programming]], a '''while loop''' is a [[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 [[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]]. 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]] of 5:

===ActionScript 3===
{{Further|ActionScript 3.0}}
<syntaxhighlight lang="actionscript">
var counter: int = 5;
var factorial: int = 1;

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

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

===Ada===
{{Further|Ada (programming language)}}
{{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===
{{Further|APL (programming language)}}
<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===
{{Further|AutoHotkey}}
<syntaxhighlight lang="autohotkey">
counter := 5
factorial := 1

While counter > 1
factorial *= counter--

MsgBox % factorial
</syntaxhighlight>

===Small Basic===
{{Further|Microsoft 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===
{{Further|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===
{{Further|Bourne 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++===
{{Further|C (programming language)|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)===
{{Further|ColdFusion Markup Language}}

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

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

writeOutput(factorial);
</syntaxhighlight>

====Tag syntax====
{{Further|Tag (programming)}}
<syntaxhighlight lang=CFM>
<cfset counter = 5>
<cfset factorial = 1>
<cfloop condition="counter GT 1">
<cfset factorial *= counter-->
</cfloop>
<cfoutput>#factorial#</cfoutput>
</syntaxhighlight>

===Fortran===
{{Further|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===
{{Further|Go (programming language)}}
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===
{{Further|Java (programming language)|C Sharp (programming language)|D (programming language)}}
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===
{{Further|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===
{{Further|Lua (programming language)}}
<syntaxhighlight lang="lua">
counter = 5
factorial = 1

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

print(factorial)
</syntaxhighlight>

===MATLAB, Octave===
{{Further|MATLAB|GNU Octave}}
<syntaxhighlight lang="matlab">
counter = 5;
factorial = 1;

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

factorial
</syntaxhighlight>

===Mathematica===
{{Further|Wolfram Mathematica|Wolfram Language}}
<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===
{{Further|Oberon (programming language)|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===
{{Further|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===
{{Further|Nim (programming language)}}
<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===
{{Further|Pascal (programming language)}}
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===
{{Further|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===
{{Further|PHP}}
<syntaxhighlight lang="php">
$counter = 5;
$factorial = 1;

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

echo $factorial;
</syntaxhighlight>

===PL/I===
{{Further|PL/I}}
The PL/I <code>DO</code> statement can act as either a [[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===
{{Further|Python (programming language)}}
<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===
{{Further|Racket (programming language)|Scheme (programming language)}}
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===
{{Further|Ruby (programming language)}}
<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===
{{Further|Rust (programming language)}}
<syntaxhighlight lang="rust">
fn main() {
let mut counter = 5;
let mut factorial = 1;

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

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

===Smalltalk===
{{Further|Smalltalk}}
Contrary to other languages, in Smalltalk a ''while'' loop is not a [[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===
{{Further|Swift (programming language)}}
<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===
{{Further|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===
{{Further|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]]

[[Category:Articles with example Ada code]]
[[Category:Articles with example BASIC code]]
[[Category:Articles with example C code]]
[[Category:Articles with example C++ code]]
[[Category:Articles with example C Sharp code]]
[[Category:Articles with example D code]]
[[Category:Articles with example Fortran code]]
[[Category:Articles with example Java code]]
[[Category:Articles with example JavaScript code]]
[[Category:Articles with example MATLAB/Octave code]]
[[Category:Articles with example Pascal code]]
[[Category:Articles with example Perl code]]
[[Category:Articles with example PHP code]]
[[Category:Articles with example Python (programming language) code]]
[[Category:Articles with example Racket code]]
[[Category:Articles with example Ruby code]]
[[Category:Articles with example Rust code]]
[[Category:Articles with example Smalltalk code]]
[[Category:Articles with example Swift code]]
[[Category:Articles with example Tcl code]]

While loop - Revision history

imported>FaviFake: update merge notice