Editing While loop

{{Short description|Control flow statement for repeating execution until a condition is met}}
{{Refimprove|date=October 2016}}
[[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 most computer [[programming language]]s, a '''while loop''' is a [[control flow]] [[Statement (computer science)|statement]] that allows code to be executed repeatedly based on a given [[Boolean data type|Boolean]] condition. The ''while'' loop can be thought of as a repeating [[Conditional (computer programming)|if statement]].

==Overview==
The ''while'' construct consists of a block of code and a condition/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 condition/expression is evaluated, and if the condition/expression is ''true'',<ref name=":0" /> the code within all of their following in the block is executed. This repeats until the condition/expression becomes [[False (logic)|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|''do while'' loop]], which tests the condition/expression ''after'' the loop has executed.

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 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 (computer science)|variable]] x has the value 5.

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 [[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>

==Demonstrating ''while'' loops==
These ''while'' loops will calculate the [[factorial]] of the number 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 > 0 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 > 0
    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 > 0
    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 > 0
    factorial = factorial * counter
    counter = counter - 1
    TextWindow.WriteLine(counter)
EndWhile

</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 > 0
    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 0 ]; do
    factorial=$((factorial * counter))
    counter=$((counter - 1))
done

echo $factorial
</syntaxhighlight>

===C, C++===
{{Further|C (programming language)|C++}}
<syntaxhighlight lang="c">
int main() {
    int count = 5;
    int factorial = 1;

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

    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 > 0)
        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>

===Lua===
{{Further|Lua (programming language)}}
<syntaxhighlight lang="lua">
counter = 5
factorial = 1

while counter > 0 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>0,            (*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="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.
</syntaxhighlight>

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

int $multiplication;

while ($counter > 0) {
    $multiplication = $factorial * $counter;

    $counter -= 1;

    print("Counter is: " + $counter + ", multiplication is: " + $multiplication + "\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 > 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
</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, '''while''' and '''repeat'''. While repeats one statement (unless enclosed in a begin-end block) as long as the condition is true. The repeat statement repetitively executes a block of one or more statements through an '''until''' statement and continues repeating unless the condition is false. The main difference between the two is the while loop may execute zero times if the condition is initially false, the repeat-until loop always executes at least once.

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

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

    begin
         Factorial := 1;

         while Counter > 0 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 > 0) {
    $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 > 0) {
    $factorial *= $counter--; // Multiply, then decrement.
}

echo $factorial;
</syntaxhighlight>

===PL/I===
{{Further|PL/I}}
<syntaxhighlight lang="rexx">
declare counter   fixed initial(5);
declare factorial fixed initial(1);

do while(counter > 0)
    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 > 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.
</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 0)
        (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 0)
    (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)}}
<syntaxhighlight lang="ruby">
# Calculate the factorial of 5
i = 1
factorial = 1

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

puts factorial
</syntaxhighlight>

===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 > 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.
</syntaxhighlight>

===Tcl===
{{Further|Tcl}}
<syntaxhighlight lang="tcl">
set counter 5
set factorial 1

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

puts $factorial
</syntaxhighlight>

===VEX===
{{Further|VEX prefix}}
<syntaxhighlight lang="csharp">
int counter = 5;
int factorial = 1;

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

printf("%d", 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]]
<!-- Hidden categories below -->
[[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]]