While loop

Template:Short description Template:Refimprove

While loop flow diagram

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.

OverviewEdit

The while construct consists of a block of code and a condition/expression.<ref name=":0">{{#invoke:citation/CS1|citation |CitationClass=web }}</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. 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 languages C, Java, C#,<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref> Objective-C, and C++, (which 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 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 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 loopsEdit

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

ActionScript 3Edit

Template:Further <syntaxhighlight lang="actionscript"> var counter: int = 5; var factorial: int = 1;

while (counter > 1) {

   factorial *= counter;
   counter--;

}

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

AdaEdit

Template:Further Template:Sister project <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>

APLEdit

Template:Further <syntaxhighlight lang="apl"> counter ← 5 factorial ← 1

While counter > 0

   factorial ×← counter
   counter -← 1

EndWhile

⎕ ← factorial </syntaxhighlight>

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

AutoHotkeyEdit

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

While counter > 0

   factorial *= counter--

MsgBox % factorial </syntaxhighlight>

Small BasicEdit

Template:Further <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 BasicEdit

Template:Further <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) shellEdit

Template:Further <syntaxhighlight lang="bash"> counter=5 factorial=1 while [ $counter -gt 0 ]; do

   factorial=$((factorial * counter))
   counter=$((counter - 1))

done

echo $factorial </syntaxhighlight>

C, C++Edit

Template:Further <syntaxhighlight lang="c"> int main() {

   int count = 5;
   int factorial = 1;

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

   printf("%d", factorial);

} </syntaxhighlight>

ColdFusion Markup Language (CFML)Edit

Template:Further

Script syntaxEdit

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

while (counter > 1) {

   factorial *= counter--;

}

writeOutput(factorial); </syntaxhighlight>

Tag syntaxEdit

Template:Further <syntaxhighlight lang=CFM> <cfset counter = 5> <cfset factorial = 1> <cfloop condition="counter GT 1">

   <cfset factorial *= counter-->

</cfloop> <cfoutput>#factorial#</cfoutput> </syntaxhighlight>

FortranEdit

Template:Further <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>

GoEdit

Template:Further 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#, DEdit

Template:Further 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>

JavaScriptEdit

Template:Further <syntaxhighlight lang="javascript"> let counter = 5; let factorial = 1;

while (counter > 1)

   factorial *= counter--;

console.log(factorial); </syntaxhighlight>

LuaEdit

Template:Further <syntaxhighlight lang="lua"> counter = 5 factorial = 1

while counter > 0 do

 factorial = factorial * counter
 counter = counter - 1

end

print(factorial) </syntaxhighlight>

MATLAB, OctaveEdit

Template:Further <syntaxhighlight lang="matlab"> counter = 5; factorial = 1;

while (counter > 0)

   factorial = factorial * counter;      %Multiply
   counter = counter - 1;                %Decrement

end

factorial </syntaxhighlight>

MathematicaEdit

Template:Further <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 PascalEdit

Template:Further <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 LanguageEdit

Template:Further <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>

NimEdit

Template:Further <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>

PascalEdit

Template:Further 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>

PerlEdit

Template:Further <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 $/ line separator) from open filehandles:

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

while (<IN>) {

   print;

}

close IN; </syntaxhighlight>

PHPEdit

Template:Further <syntaxhighlight lang="php"> $counter = 5; $factorial = 1;

while ($counter > 0) {

   $factorial *= $counter--; // Multiply, then decrement.

}

echo $factorial; </syntaxhighlight>

PL/IEdit

Template:Further <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>

PythonEdit

Template:Further <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>

RacketEdit

Template:Further In Racket, as in other 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.

RubyEdit

Template:Further <syntaxhighlight lang="ruby">

Calculate the factorial of 5

i = 1 factorial = 1

while i <= 5

 factorial *= i
 i += 1

end

puts factorial </syntaxhighlight>

RustEdit

Template:Further <syntaxhighlight lang="rust"> fn main() {

   let mut counter = 5;
   let mut factorial = 1;

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

   println!("{}", factorial);

} </syntaxhighlight>

SmalltalkEdit

Template:Further 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.

<syntaxhighlight lang="smalltalk"> | count factorial | count := 5. factorial := 1. [count > 0] whileTrue:

   [factorial := factorial * count.
   count := count - 1].

Transcript show: factorial </syntaxhighlight>

SwiftEdit

Template:Further <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>

TclEdit

Template:Further <syntaxhighlight lang="tcl"> set counter 5 set factorial 1

while {$counter > 0} {

   set factorial [expr $factorial * $counter]
   incr counter -1

}

puts $factorial </syntaxhighlight>

VEXEdit

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

while (counter > 1)

   factorial *= counter--;

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

PowerShellEdit

Template:Further <syntaxhighlight lang="powershell"> $counter = 5 $factorial = 1

while ($counter) {

   $factorial *= $counter--

}

$factorial </syntaxhighlight>

While (language)Edit

While<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</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.<ref name="NielsonNielson1999">Template:Cite book</ref><ref>Template:Cite book</ref> <syntaxhighlight lang="whiley"> C := 5; F := 1;

while (C > 1) do

   F := F * C;
   C := C - 1;

</syntaxhighlight>

ReferencesEdit

Template:Reflist

While loop

OverviewEdit

Demonstrating while loopsEdit

ActionScript 3Edit

AdaEdit

APLEdit

AutoHotkeyEdit

Small BasicEdit

Visual BasicEdit

Bourne (Unix) shellEdit

C, C++Edit

ColdFusion Markup Language (CFML)Edit

Script syntaxEdit

Tag syntaxEdit

FortranEdit

GoEdit

Java, C#, DEdit

JavaScriptEdit

LuaEdit

MATLAB, OctaveEdit

MathematicaEdit

Oberon, Oberon-2, Oberon-07, Component PascalEdit

Maya Embedded LanguageEdit

NimEdit

PascalEdit

PerlEdit

PHPEdit

PL/IEdit

PythonEdit

RacketEdit

RubyEdit

RustEdit

SmalltalkEdit

SwiftEdit

TclEdit

VEXEdit

PowerShellEdit

While (language)Edit

See alsoEdit

ReferencesEdit