Mientras bucle - While loop

Mientras que el diagrama de flujo de bucle
Construcciones de bucle

En la mayoría de los lenguajes de programación de computadoras, un bucle while es una declaración de flujo de control que permite que el código se ejecute repetidamente en función de una condición booleana determinada . El tiempo de bucle puede ser pensado como una repetición si la declaración .

Visión general

La construcción while consta de un bloque de código y una condición / expresión. La condición / expresión se evalúa, y si la condición / expresión es verdadera , se ejecuta el código dentro de todos sus siguientes en el bloque. Esto se repite hasta que la condición / expresión se vuelve falsa . Debido a que los mientras cheques bucle se ejecuta la condición / expresión antes de que el bloque, la estructura de control a menudo también se conoce como un bucle de pre-prueba . Compare esto con el ciclo do while , que prueba la condición / expresión después de que el ciclo se ha ejecutado.

Por ejemplo, en el lenguaje de programación C (así como en Java , C # , Objective-C y C ++ , que usan la misma sintaxis en este caso), el fragmento de código 

int x = 0;

while (x < 5) {
    printf ("x = %d\n", x);
    x++;
}

primero verifica si x es menor que 5, que es, entonces se ingresa el {cuerpo del bucle}, donde se ejecuta la función printf y x se incrementa en 1. Después de completar todas las declaraciones en el cuerpo del bucle, la condición, ( x <5), se comprueba de nuevo y se vuelve a ejecutar el ciclo, repitiéndose este proceso hasta que la variable x tiene el valor 5.

Tenga en cuenta que es posible, y en algunos casos deseable, que la condición siempre se evalúe como verdadera, creando un bucle infinito . Cuando un bucle de este tipo se crea intencionalmente, suele haber otra estructura de control (como una declaración de interrupción ) que controla la terminación del bucle. Por ejemplo: 

while (true) {
    // do complicated stuff
    if (someCondition)
        break;
    // more stuff
}

Demostrando mientras que los bucles

Estas mientras bucles calcular el factorial del número 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

Shell Bourne (Unix) 

counter=5
factorial=1
while [ $counter -gt 0 ]; do
    factorial=$((factorial * counter))
    counter=$((counter - 1))
done

echo $factorial

C o C ++ 

int main() {
    int counter = 5;
    int factorial = 1;

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

    printf("%d", factorial);
}

CFML

Sintaxis de la secuencia de comandos

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

writeOutput(factorial);

Sintaxis de la etiqueta

<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

Ir

Go no tiene una instrucción whiile, pero tiene la función de una instrucción for si omite algunos elementos de la instrucción for. 

counter, factorial := 5, 1

for counter > 1 {
	counter, factorial = counter-1, factorial*counter
}

Java , C # , D

El código para el bucle es el mismo para Java, C # y 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 y 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 (lenguaje de programación) , Oberon-07 o 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.

Lenguaje incrustado maya

int $counter = 5;
int $factorial = 1;

int $multiplication;

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

    $counter -= 1;
    
    print("Counter is: " + $counter + ", multiplication is: " + $multiplication + "\n");
}

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

Bucle while sin terminación: 

while true:
  echo "Help! I'm stuck in a loop!"

Pascal

Pascal tiene dos formas del bucle while, while y repeat . Mientras repite una declaración (a menos que esté incluida en un bloque de inicio-fin) siempre que la condición sea verdadera. La instrucción repeat ejecuta repetidamente un bloque de una o más declaraciones a través de una instrucción hasta y continúa repitiéndose a menos que la condición sea falsa. La principal diferencia entre los dos es que el ciclo while puede ejecutarse cero veces si la condición es inicialmente falsa, el ciclo repeat-until siempre se ejecuta al menos una vez. 

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.

Perl

my $counter   = 5;
my $factorial = 1;

while ($counter > 0) {
    $factorial *= $counter--; # Multiply, then decrement
}

print $factorial;

Mientras que los bucles se utilizan con frecuencia para leer datos línea por línea (según lo definido por el $/separador de línea) de identificadores de archivos abiertos: 

open IN, "<test.txt";

while (<IN>) {
    print;
}

close IN;

PHP

$counter = 5;
$factorial = 1;

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

echo $factorial;

PL / I 

declare counter   fixed initial(5);
declare factorial fixed initial(1);

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

Pitón

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.

Bucle while sin terminación: 

while True:
    print("Help! I'm stuck in a loop!")

Raqueta

En Racket, como en otras implementaciones de Scheme , un let con nombre es una forma popular de implementar bucles: 

#lang racket
(define counter 5)
(define factorial 1)
(let loop ()
    (when (> counter 0)
        (set! factorial (* factorial counter))
        (set! counter (sub1 counter))
        (loop)))
(displayln factorial)

El uso de un sistema de macro, la implementación de un tiempo de bucle es un ejercicio trivial (comúnmente usado para introducir 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)

Pero tenga en cuenta que un estilo de programación imperativo a menudo se desaconseja en Racket (como en Scheme).

Rubí

# Calculate the factorial of 5
i = 1
factorial = 1

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

puts factorial

Oxido

fn main() {
    let mut counter = 5;
    let mut factorial = 1;

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

    println!("{}", factorial);
}

Charla

Contrariamente a otros idiomas, en Smalltalk un mientras bucle no es una construcción del lenguaje pero definido en la clase BlockClosurecomo un método con un parámetro, el cuerpo como un cierre , con el mismo como la condición.

Smalltalk también tiene un método whileFalse: correspondiente. 

| count factorial |
count := 5.
factorial := 1.
[count > 0] whileTrue: 
    [factorial := factorial * count.
    count := count - 1].
Transcript show: factorial

Rápido

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

VEJAR

int counter = 5;
int factorial = 1;

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

printf("%d", factorial);

Potencia Shell

$counter = 5
$factorial = 1

while ($counter) {
    $factorial *= $counter--
}

$factorial

Mientras que el lenguaje de programación

El lenguaje de programación While es un lenguaje de programación simple construido a partir de asignaciones, composición secuencial, condicionales y declaraciones while, que se utiliza en el análisis teórico de la semántica del lenguaje de programación imperativo . 

C := 5;
F := 1;

while (C > 1) do
    F := F * C;
    C := C - 1;

Ver también

Referencias