While loop

While loop flow diagram

Loop constructs
Do while loop
While loop
For loop
Foreach loop
Infinite loop
Control flow

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

Equivalent constructs

In the C programming language,

while (condition) 
{
   statements;
}

is equivalent to

if (condition) 
{
   do 
   {
      statements;
   } while (condition);
}

while (true) 
{
   if (!condition) break;
   statements;
}

   goto TEST;
LOOPSTART:
   statements;
TEST:
   if (condition) goto LOOPSTART;

TEST:
   if (!condition) goto LOOPEND;
   statements
   goto TEST;
LOOPEND:

Those last two are not recommended because the use of "goto" statements makes it hard for a programmer to understand the flow of control, and is generally regarded as a last resort.

Also, in C and its descendants, a while loop is a for loop with no initialization or counting expressions, i.e.,

for ( ; condition; )
{
   statements;
}

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;

Basic (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(void)
{
    int counter = 5;
    long factorial = 1;
 
    while (counter > 1)
    {
        factorial *= counter--;
    }
    printf("%d", factorial);
    return 0;
}

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;
long factorial = 1;

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

For Java the result is printed as follows:

System.out.println(factorial);

The same in C#

System.Console.WriteLine(factorial);

And finally in D

writefln(factorial);

JavaScript

var counter = 5;
var factorial = 1;

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

document.write(factorial);

Lua

counter = 5
factorial = 1

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

print(factorial)

MATLAB

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");
}

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 first.
  $counter--; // then decrement.
}
print $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 
                                      # factorial x counter.
    
    counter -= 1                      # Set the new value of 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

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 value to 5 
var 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 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);

Windows PowerShell

$number = 5
$counter = $number
$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;

References

1 2 "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.

This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.