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 bucle while puede considerarse como una declaración if repetida .
La construcción while consta de un bloque de código y una condición/expresión. [1] Se evalúa la condición/expresión y, si la condición/expresión es verdadera , [1] se ejecuta el código dentro de todos los siguientes 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 ejecutar el bloque, la estructura de control a menudo también se conoce como bucle de prueba previa . Compare 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 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 verifica nuevamente y el bucle se ejecuta nuevamente, 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 un bucle de este tipo se crea intencionadamente, suele haber otra estructura de control (como una sentencia break ) que controla la terminación del bucle. Por ejemplo:
while ( true ) { // hacer cosas complicadas si ( someCondition ) se rompe ; // mas cosas } Estos bucles while calcularán el factorial del número 5:
contador var : int = 5 ; var factorial : int = 1 ; mientras ( contador > 1 ) { factorial *= contador ; encimera --; } 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 ; bucle final ; Ada . Entero_Texto_IO . Poner ( Factorial ); fin Factorial ;contador ← 5 factorial ← 1 : Contador Mientras > 0 factorial × ← contador contador - ← 1 : EndWhile ⎕ ← factores o simplemente
! 5contador := 5 factorial := 1Mientras contador > 0 factorial *= contador --MsgBox % factorialcontador = 5 ' Contador = 5 factorial = 1 ' valor inicial de la variable "factorial" Mientras que contador > 0 factorial = factorial * contador contador = contador -1 TextWindow . WriteLine ( contador ) EndWhile Contador tenue As Integer = 5 ' variable de inicio y valor establecido Dim factorial As Integer = 1 ' inicializar variable factorial Hacer Mientras contador > 0 factorial = factorial * contador contador = contador - 1 El programa del bucle va aquí, hasta que 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 principal () { int recuento = 5 ; entero factorial = 1 ; mientras ( recuento > 1 ) factorial *= recuento -- ; printf ( "%d" , factorial ); } contador = 5 ; factoriales = 1 ;mientras ( contador > 1 ) { factorial *= contador -- ; }escribirSalida ( factorial );<cfset contador = 5 > <cfset factorial = 1 > <cfloop condition = "counter 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 * , fin del programa factorial FactorialProg Go no tiene una declaración while , pero tiene la función de una declaración for al omitir 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:
contador int = 5 ; entero factorial = 1 ; while ( contador > 1 ) factorial *= contador -- ; dejar contador = 5 ; sea factorial = 1 ; while ( contador > 1 ) factorial *= contador -- ; consola . iniciar sesión ( factorial );contador = 5 factorial = 1mientras contador > 0 hacer factorial = factorial * contador contador = contador - 1 finimprimir ( factorial )contador = 5 ; factoriales = 1 ; mientras ( contador > 0 ) factorial = factorial * contador ; %Multiplicar contador = contador - 1 ; % Final de disminución factorialBloquear [{ contador = 5 , factorial = 1 }, (*localizar contador y factorial*) While [ contador > 0 , (*While bucle*) factorial *= contador ; (*Multiplicar*) contador -- ; (*Decremento*) ]; factoriales ]MÓDULO Factorial ; IMPORTAR Fuera ; Contador VAR , Factorial : ENTERO ; COMENZAR Contador := 5 ; Factoriales := 1 ; MIENTRAS Contador > 0 DO Factorial := Factorial * Contador ; DEC ( Contador ) FINAL ; Afuera . Int ( Factorial , 0 ) FINAL Factorial . int $contador = 5 ; int $factorial = 1 ; int $multiplicación ; while ( $contador > 0 ) { $multiplicación = $factorial * $contador ; $contador -= 1 ; print ( "El contador es: " + $contador + ", la multiplicación es: " + $multiplicación + "\n" ); } var contador = 5 # Establecer el valor del contador en 5 factorial = 1 # Establecer el valor factorial en 1 while contador > 0 : # Mientras el contador es mayor que 0 factorial *= contador # Establece un nuevo valor de factorial en el contador. contador dec # Establezca el contador en contador - 1. eco factorial Bucle while sin terminación:
while true : echo "¡Ayuda! ¡Estoy atrapado en un bucle!" Pascal tiene dos formas de bucle while, while y repetir . Mientras repite una declaración (a menos que esté incluida en un bloque de inicio-fin) siempre que la condición sea verdadera. La declaración de repetición ejecuta repetidamente un bloque de una o más declaraciones a través de una declaración hasta y continúa repitiendo 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 repetir hasta que siempre se ejecuta al menos una vez.
programa Factorial1 ; varFv : entero ; _ hecho del procedimiento ( contador : entero ) ; var Factorial : entero ; comenzar Factorial := 1 ; mientras que Contador > 0 comienza Factorial : = Factorial * Contador ; Contador := Contador - 1 final ; WriteLn ( Factorial ) final ; comenzar a escribir ( 'Ingrese un número para devolver su factorial: ' ) ; readln ( fv ) ; repetir hecho ( fv ) ; Write ( 'Ingrese otro número para devolver su factorial (o 0 para salir): ' ) ; hasta fv = 0 ; fin . mi $contador = 5 ; mi $factorial = 1 ; while ( $contador > 0 ) { $factorial *= $contador -- ; # Multiplicar y luego disminuir } 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 EN , "<test.txt" ; mientras ( <EN> ) { imprimir ; } acercarse ; _ $contador = 5 ; $factorial = 1 ;while ( $contador > 0 ) { $factorial *= $contador -- ; // Multiplica y luego disminuye. }eco $factorial ;declarar contador fijo inicial ( 5 ) ; declarar inicial fija factorial ( 1 ) ; hacer while ( contador > 0 ) factorial = factorial * contador ; contador = contador - 1 ; fin ; contador = 5 # Establece el valor en 5 factorial = 1 # Establece el valor en 1while contador > 0 : # Mientras que el contador (5) es mayor que 0 factorial *= contador # Establece un nuevo valor de factorial en el contador. contador -= 1 # Establezca el contador en contador - 1.print ( factorial ) # Imprime el valor del factorial.Bucle while sin terminación:
while True : print ( "¡Ayuda! ¡Estoy atrapado en un bucle!" )En Racket, como en otras implementaciones de Scheme , un nombre-let es una forma popular de implementar bucles:
#lang raqueta ( definir contador 5 ) ( definir factorial 1 ) ( let loop () ( cuando ( > contador 0 ) ( set! factorial ( * contador factorial )) ( set! contador ( sub1 contador )) ( bucle ))) ( visualización en factorial ) Usando un sistema de macros, implementar un bucle while es un ejercicio trivial (comúnmente usado para introducir macros):
#lang raqueta ( definir-sintaxis-regla ( mientras cuerpo de prueba ... ) ; implementa un bucle while ( let loop () ( cuando cuerpo de prueba ... ( bucle )))) ( definir contador 5 ) ( definir factorial 1 ) ( while ( > contador 0 ) ( set! factorial ( * contador factorial ) ) ( set! contador ( contador sub1 ))) ( displayln factorial ) Sin embargo, a menudo se desaconseja un estilo de programación imperativo en Scheme y Racket.
# Calcular el factorial de 5 i = 1 factorial = 1 mientras i <= 5 factorial *= i i += 1 final pone factorial fn main () { let mut contador = 5 ; sea mut factorial = 1 ; mientras contador > 1 { factorial *= contador ; contador -= 1 ; } imprimir! ( "{}" , 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 cierre , usando self como condición.
Smalltalk también tiene un método whileFalse: correspondiente.
| contar factoriales | contar : = 5 . factoriales := 1 . [ recuento > 0 ] whileTrue: [ factorial := factorial * recuento . contar := contar - 1 ] . Programa de transcripción : factorialvar contador = 5 // Establece el valor del contador inicial en 5 var factorial = 1 // Establece el valor factorial inicial en 1while contador > 0 { // Mientras que el contador (5) es mayor que 0 factorial *= contador // Establece el nuevo valor del factorial en el contador factorial x. contador -= 1 // Establece el nuevo valor del contador en contador - 1. }print ( factorial ) // Imprime el valor del factorial.establecer contador 5 establecer factorial 1 while { $contador > 0 } { establecer factorial [expr $factorial * $contador ] incr contador - 1 } pone $factorial contador int = 5 ; entero factorial = 1 ; while ( contador > 1 ) factorial *= contador -- ; printf ( "%d" , factorial ); $contador = 5 $factorial = 1while ( $contador ) { $factorial *= $contador -- }$factorialesMientras 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 que ( C > 1 ) haz F := F * C ; C := C - 1 ;