En la mayoría de los lenguajes de programación informática , un bucle while es una sentencia de flujo de control que permite ejecutar código repetidamente en función de una condición booleana determinada . El bucle while puede considerarse como una sentencia if repetitiva .
La construcción while consta de un bloque de código y una condición/expresión. [1] La condición/expresión se evalúa y, si la condición/expresión es verdadera , [1] se ejecuta el código dentro de todos los que le siguen en el bloque. Esto se repite hasta que la condición/expresión se vuelve falsa . Debido a que el bucle while verifica la condición/expresión antes de que se ejecute el bloque, la estructura de control a menudo también se conoce como bucle de pre-prueba . Compárese esto con el bucle do while , que prueba la condición/expresión después de que se haya ejecutado el bucle.
Por ejemplo, en los lenguajes C , Java , C# , [2] Objective-C y C++ (que utilizan la misma sintaxis en este caso), el fragmento de código
int x = 0 ; mientras ( x < 5 ) { printf ( "x = %d \n " , x ); x ++ ; } primero verifica si x es menor que 5, lo cual es, luego se ingresa al {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, se verifica nuevamente la condición (x < 5) y se ejecuta nuevamente el bucle, repitiéndose este proceso hasta que la variable x tenga el valor 5.
Es posible, y en algunos casos deseable, que la condición siempre se evalúe como verdadera, creando un bucle infinito . Cuando se crea un bucle de este tipo intencionalmente, suele haber otra estructura de control (como una declaración break ) que controla la finalización del bucle. Por ejemplo:
mientras ( verdadero ) { // hacer cosas complicadas si ( algunaCondición ) romper ; // más cosas } Estos bucles while calcularán el factorial del número 5:
var contador : int = 5 ; var factorial : int = 1 ; mientras ( contador > 1 ) { factorial *= contador ; contador --; } Printf ( "Factorial = %d" , factorial ); 
con Ada.Integer_Text_IO ;procedimiento Factorial es Contador : Entero := 5 ; Factorial : Entero := 1 ; comenzar mientras Contador > 0 bucle Factorial := Factorial * Contador ; Contador := Contador - 1 ; fin bucle ; Ada . Integer_Text_IO . Put ( Factorial ); fin Factorial ;contador ← 5 factorial ← 1 : Mientras contador > 0 factorial × ← contador contador - ← 1 : FinMientras ⎕ ← factorial o simplemente
! 5contador := 5 factorial := 1Mientras contador > 0 factorial *= contador --Cuadro de mensaje % factorialcontador = 5 ' contador = 5 factorial = 1 ' valor inicial de la variable "factorial" Mientras contador > 0 factorial = factorial * contador contador = contador - 1 TextWindow . WriteLine ( contador ) EndWhile Contador Dim Como Entero = 5 ' inicializar variable y establecer valor. Factorial Dim Como Entero = 1 ' inicializar variable factorial Hacer Mientras contador > 0 factorial = factorial * contador contador = contador - 1 Bucle ' el programa va aquí, hasta contador = 0 'Debug.Print factorial' Console.WriteLine(factorial) en Visual Basic .NETcontador = 5 factorial = 1 mientras [ $contador -gt 0 ] ; hacer factorial = $(( factorial * contador )) contador = $(( contador - 1 )) hecho eco $factorial int main () { int conteo = 5 ; int factorial = 1 ; mientras ( contar > 1 ) factorial *= contar -- ; printf ( "%d" , factorial ); } contador = 5 ; factorial = 1 ;mientras ( contador > 1 ) { factorial *= contador -- ; }escribirSalida ( factorial );<cfset contador = 5 > <cfset factorial = 1 > <cfloop condición = "contador GT 1" > <cfset factorial *= contador -- > </cfloop> <cfoutput> # factorial # </cfoutput>programa FactorialProg entero :: contador = 5 entero :: factorial = 1 hacer mientras ( contador > 0 ) factorial = factorial * contador contador = contador - 1 fin hacer imprimir * , factorial fin del programa FactorialProg Go no tiene una declaración while , pero tiene la función de una declaración for cuando se omiten algunos elementos de la declaración for .
contador , factorial := 5 , 1 para contador > 1 { contador , factorial = contador - 1 , factorial * contador } El código para el bucle es el mismo para Java, C# y D:
int contador = 5 ; int factorial = 1 ; mientras ( contador > 1 ) factorial *= contador -- ; sea contador = 5 ; sea factorial = 1 ; mientras ( contador > 1 ) factorial *= contador -- ; consola .log ( factorial ) ;contador = 5 factorial = 1mientras contador > 0 hacer factorial = factorial * contador contador = contador - 1 fin imprimir ( factorial )contador = 5 ; factorial = 1 ; mientras ( contador > 0 ) factorial = factorial * contador ; %Multiplicar contador = contador - 1 ; %Decrementar fin factorialBloque [{ contador = 5 , factorial = 1 }, (*localizar contador y factorial*) While [ contador > 0 , (*bucle While*) factorial *= contador ; (*Multiplicar*) contador -- ; (*Decrementar*) ]; factorial ]MÓDULO Factorial ; IMPORTAR Salida ; VAR Contador , Factorial : ENTERO ; COMIENZO Contador := 5 ; Factorial := 1 ; MIENTRAS Contador > 0 HACER Factorial := Factorial * Contador ; DEC ( Contador ) FIN ; Salida . Int ( Factorial , 0 ) FIN Factorial . int $contador = 5 ; int $factorial = 1 ; int $multiplicación ; mientras ( $contador > 0 ) { $multiplicación = $factorial * $contador ; $contador -= 1 ; print ( "El contador es: " + $contador + ", la multiplicación es: " + $multiplicación + "\n" ); } var counter = 5 # Establece el valor del contador en 5 factorial = 1 # Establece el valor factorial en 1 mientras contador > 0 : # Mientras contador sea mayor que 0 factorial *= contador # Establezca el nuevo valor de factorial en contador. dec contador # Establezca el contador en contador - 1. factorial de eco Bucle while sin terminación:
mientras sea verdadero : echo "¡Ayuda! ¡Estoy atrapado en un bucle!" Pascal tiene dos formas del bucle while, while y repeat . While repite una instrucción (a menos que esté encerrada en un bloque begin-end) siempre que la condición sea verdadera. La instrucción repeat ejecuta repetidamente un bloque de una o más instrucciones a través de una instrucción till y continúa repitiéndose a menos que la condición sea falsa. La principal diferencia entre los dos es que el bucle while puede ejecutarse cero veces si la condición es inicialmente falsa, el bucle repeat-until siempre se ejecuta al menos una vez.
programa Factorial1 ; varFv : entero ; procedimiento hecho ( contador : entero ) ; var Factorial : entero ; comienza Factorial := 1 ; mientras Contador > 0 hacer comenzar Factorial := Factorial * Contador ; Contador := Contador - 1 fin ; WriteLn ( Factorial ) fin ; begin Write ( 'Ingrese un número para devolver su factorial: ' ) ; readln ( fv ) ; repeat fact ( fv ) ; Write ( 'Ingrese otro número para devolver su factorial (o 0 para salir): ' ) ; hasta fv = 0 ; fin . mi $contador = 5 ; mi $factorial = 1 ; mientras ( $contador > 0 ) { $factorial *= $contador -- ; # Multiplicar, luego decrementar } imprimir $factorial ; Los bucles While se utilizan con frecuencia para leer datos línea por línea (según lo definido por el $/separador de línea) desde identificadores de archivos abiertos:
abrir IN , "<test.txt" ; mientras ( <IN> ) { imprimir ; } cerrar EN ; $contador = 5 ; $factorial = 1 ;mientras ( $contador > 0 ) { $factorial *= $contador -- ; // Multiplica, luego decrementa. }eco $factorial ;declarar contador fijo inicial ( 5 ) ;
declarar factorial fijo inicial ( 1 ) ;hacer mientras ( contador > 0 ) factorial = factorial * contador ; contador = contador - 1 ; fin ; contador = 5 # Establezca el valor en 5 factorial = 1 # Establezca el valor en 1mientras contador > 0 : # Mientras contador(5) sea mayor que 0 factorial *= contador # Establezca el nuevo valor de factorial en contador. contador -= 1 # Establezca el contador en contador - 1.print ( factorial ) # Imprime el valor del factorial.Bucle while sin terminación:
mientras True : print ( "¡Ayuda! ¡Estoy atrapado en un bucle!" )En Racket, como en otras implementaciones de Scheme , un named-let es una forma popular de implementar bucles:
#lang racket ( define contador 5 ) ( define factorial 1 ) ( let loop () ( when ( > contador 0 ) ( set! factorial ( * factorial contador )) ( set! contador ( sub1 contador )) ( loop ))) ( displayln factorial ) Usando un sistema de macros, implementar un bucle while es un ejercicio trivial (usado comúnmente para introducir macros):
#lang racket ( define-syntax-rule ( while cuerpo de la prueba ... ) ; implementa un bucle while ( let loop () ( when cuerpo de la prueba ... ( loop )))) ( define contador 5 ) ( define factorial 1 ) ( while ( > contador 0 ) ( set! factorial ( * contador factorial )) ( set! counter ( sub1 contador ))) ( displayln factorial ) Sin embargo, en Scheme y Racket a menudo se desaconseja el estilo de programación imperativo.
# Calcular el factorial de 5 i = 1 factorial = 1 mientras i <= 5 factorial *= i i += 1 fin pone factorial fn main () { dejar mut contador = 5 ; dejar mut factorial = 1 ; mientras contador > 1 { factorial *= contador ; contador -= 1 ; } println! ( "{}" , factorial ); } A diferencia de otros lenguajes, en Smalltalk un bucle while no es una construcción del lenguaje , sino que se define en la clase BlockClosurecomo un método con un parámetro, el cuerpo como un cierre , utilizando self como 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 ] . Transcripción mostrar: factorialvar counter = 5 // Establece el valor del contador inicial en 5 var factorial = 1 // Establece el valor factorial inicial en 1mientras contador > 0 { // Mientras contador(5) sea mayor que 0 factorial *= contador // Establezca el nuevo valor de factorial en factorial x contador. contador -= 1 // Establezca el nuevo valor de contador en contador - 1. }print ( factorial ) // Imprime el valor del factorial.Establecer contador 5 Establecer factorial 1 mientras { $contador > 0 } { establecer factorial [expr $factorial * $contador ] incr contador - 1 } pone $factorial int contador = 5 ; int factorial = 1 ; mientras ( contador > 1 ) factorial *= contador -- ; printf ( "%d" , factorial ); $contador = 5 $factorial = 1mientras ( $contador ) { $factorial *= $contador -- }$factorialMientras que [3] es un lenguaje de programación simple construido a partir de asignaciones, composición secuencial, condicionales y declaraciones while, utilizado en el análisis teórico de la semántica del lenguaje de programación imperativo . [4] [5]
C := 5 ; F := 1 ;mientras ( C > 1 ) hacer F := F * C ; C := C - 1 ;