# While loop

Loop constructs |
---|

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

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

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;

### AutoHotkey

counter := 5 factorial := 1 While counter > 0 factorial *= counter-- MsgBox % factorial

### Microsoft Small Basic

counter = 5 ' Counter = 5 factorial = 1 ' initial value of variable "factorial" While counter > 0 factorial = factorial * counter counter = counter - 1 TextWindow.WriteLine(counter) EndWhile

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

#### 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; int factorial = 1; while (counter > 1) factorial *= counter--;

### JavaScript

let counter = 5; let factorial = 1; while (counter > 1) factorial *= counter--; console.log(factorial);

### Lua

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

### MATLAB & GNU Octave

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 counter. counter -= 1 # Set the 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

### Rust

fn main() { let mut counter = 5; let mut factorial = 1; while counter > 1 { factorial *= counter; counter -= 1; } println!("{}", 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 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.

### 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);

### PowerShell

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

## See also

- Do while loop
- For loop
- Foreach
- LOOP (programming language) – a programming language with the property that the functions it can compute are exactly the primitive recursive functions

## References

- ↑
^{1.0}^{1.1}"The while and do-while Statements (The Java™ Tutorials > Learning the Java Language > Language Basics)". http://docs.oracle.com/javase/tutorial/java/nutsandbolts/while.html. Retrieved 2016-10-21. - ↑ "while (C# reference)". http://msdn.microsoft.com/en-us/library/2aeyhxcd.aspx. Retrieved 2016-10-21.
- ↑ "Chapter 3 : The While programming language" (PDF). http://profs.sci.univr.it/~merro/files/WhileExtra_l.pdf. Retrieved 2016-10-21.
- ↑ Flemming Nielson; Hanne R. Nielson; Chris Hankin (1999).
*Principles of Program Analysis*. Springer. ISBN 978-3-540-65410-0. https://books.google.com/books?id=RLjt0xSj8DcC. Retrieved 29 May 2013. - ↑ Illingworth, Valerie (11 December 1997).
*Dictionary of Computing*. Oxford Paperback Reference (4th ed.). Oxford University Press. ISBN 9780192800466. https://archive.org/details/dictionaryofcomp00illi.

Original source: https://en.wikipedia.org/wiki/ While loop.
Read more |