En muchos lenguajes de programación informática , un bucle do while es una declaración de flujo de control que ejecuta un bloque de código y luego repite el bloque o sale del bucle dependiendo de una condición booleana dada.
La construcción do while consta de un símbolo de proceso y una condición. Primero se ejecuta el código dentro del bloque. Luego se evalúa la condición. Si la condición es verdadera, el código dentro del bloque se ejecuta nuevamente. Esto se repite hasta que la condición se vuelve falsa .
Los bucles do while comprueban la condición después de que se ejecuta el bloque de código. Esta estructura de control se puede conocer como bucle de post-prueba . Esto significa que el bucle do-while es un bucle de condición de salida. Sin embargo, un bucle while probará la condición antes de que se ejecute el código dentro del bloque.
Esto significa que el código siempre se ejecuta primero y luego se evalúa la expresión o condición de prueba. Este proceso se repite siempre que la expresión se evalúe como verdadera. Si la expresión es falsa, el bucle termina. Un bucle while establece la verdad de una declaración como condición necesaria para la ejecución del código. Un bucle do-while permite la ejecución continua de la acción hasta que la condición ya no sea verdadera.
Es posible y, a veces, deseable que la condición siempre se evalúe como verdadera. Esto crea un bucle infinito . Cuando se crea un bucle infinito intencionalmente, generalmente hay otra estructura de control que permite la terminación del bucle. Por ejemplo, una declaración break permitiría la terminación de un bucle infinito.
Algunos lenguajes pueden usar una convención de nombres diferente para este tipo de bucle. Por ejemplo, los lenguajes Pascal y Lua tienen un bucle " repetir hasta ", que continúa ejecutándose hasta que la expresión de control sea verdadera y luego finaliza. En contraste, un bucle "while" se ejecuta mientras la expresión de control sea verdadera y finaliza una vez que la expresión se vuelve falsa. Considere un programa que juega un juego "adivina el número". Su programa elige el número que se debe adivinar seleccionando un entero al azar en un rango de 1 a 1000.
hacer { hacer_trabajo (); } mientras ( condición ); es equivalente a
hacer_trabajo ();mientras ( condición ) { hacer_trabajo (); } De esta manera, el bucle do... while guarda el "preparado del bucle" inicial do_work();en la línea anterior al whilebucle.
Siempre que no se utilice la declaración continue , lo anterior es técnicamente equivalente a lo siguiente (aunque estos ejemplos no son típicos ni del estilo moderno que se utiliza en las computadoras de todos los días):
mientras ( verdadero ) { hacer_trabajo (); si ( ! condición ) romper ; } o
LOOPSTART : hacer_trabajo (); si ( condición ) pasa a LOOPSTART ; Estos programas de ejemplo calculan el factorial de 5 utilizando la sintaxis de sus respectivos lenguajes para un bucle do-while.
con Ada.Integer_Text_IO ;procedimiento Factorial es Contador : Entero := 5 ; Factorial : Entero := 1 ; comenzar bucle Factorial := Factorial * Contador ; Contador := Contador - 1 ; salir cuando Contador = 0 ; fin bucle ; Ada . Integer_Text_IO . Put ( Factorial ); fin Factorial ;Los primeros BASIC (como GW-BASIC ) utilizaban la sintaxis WHILE/WEND. Los BASIC modernos, como PowerBASIC , proporcionan estructuras WHILE/WEND y DO/LOOP, con sintaxis como DO WHILE/LOOP, DO UNTIL/LOOP, DO/LOOP WHILE, DO/LOOP UNTIL y DO/LOOP (sin pruebas externas, pero con un EXIT LOOP condicional en algún lugar dentro del bucle). Código fuente típico de BASIC:
Dim factorial como entero Dim contador como entero factorial = 1 contador = 5 Hacer factorial = factorial * contador contador = contador - 1 Bucle Mientras contador > 0 Impresión factorial int contador = 5 ; int factorial = 1 ; do { factorial *= contador -- ; /* Multiplica, luego decrementa. */ } while ( contador > 0 ); printf ( "factorial de 5 es %d \n " , factorial ); Las instrucciones do-while(0) también se usan comúnmente en macros de C como una forma de encapsular múltiples instrucciones en una instrucción regular (en lugar de una instrucción compuesta). Hace que se necesite un punto y coma después de la macro, lo que proporciona una apariencia más parecida a una función para programadores y analizadores simples, además de evitar el problema de alcance con if. Se recomienda en la regla PRE10-C del estándar de codificación C de CERT . [1]
Con el legado de Fortran 77 no existe la construcción DO-WHILE pero se puede lograr el mismo efecto con GOTO:
ENTERO CNT , HECHO CNT = 5 HECHO = 1 1 CONTINUAR HECHO = HECHO * CNT CNT = CNT - 1 SI ( CNT . GT . 0 ) IR A 1 IMPRIMIR * , HECHO FIN Fortran 90 y versiones posteriores tampoco tienen una construcción do-while, pero sí tienen una construcción de bucle while que utiliza las palabras clave "do while" y, por lo tanto, es en realidad lo mismo que el bucle for . [2]
programa FactorialProg entero :: contador = 5 entero :: factorial = 1 factorial = factorial * contador contador = contador - 1 do while ( contador > 0 ) ! El valor de verdad se prueba antes del bucle factorial = factorial * contador contador = contador - 1 fin do imprimir * , factorial fin del programa FactorialProg int contador = 5 ; int factorial = 1 ; do { factorial *= contador -- ; /* Multiplica, luego decrementa. */ } while ( contador > 0 ); Sistema . out . println ( "El factorial de 5 es " + factorial ); Pascal utiliza la sintaxis repeat/until en lugar de do while.
factorial := 1 ; contador := 5 ; repetir factorial := factorial * contador ; contador := contador - 1 ; // En Object Pascal se puede usar dec (contador); hasta que contador = 0 ; La instrucción PL/I DO incluye las funciones del bucle posterior a la prueba ( do till ), el bucle anterior a la prueba ( do while ) y el bucle for . Todas las funciones se pueden incluir en una sola instrucción. El ejemplo muestra solo la sintaxis "do till".
declarar contador fijo inicial ( 5 ) ;
declarar factorial fijo inicial ( 1 ) ;hacer hasta ( contador <= 0 ) ; factorial = factorial * contador ; contador = contador - 1 ; fin ; poner ( factorial ) ;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 () ( set! factorial ( * factorial contador )) ( set! contador ( sub1 contador )) ( when ( > contador 0 ) ( loop ))) ( displayln factorial ) Compare esto con el primer ejemplo del bucle while para Racket. Tenga en cuenta que un let con nombre también puede aceptar argumentos.
Racket y Scheme también proporcionan un bucle do apropiado.
( define ( factorial n ) ( do (( contador n ( - contador 1 )) ( resultado 1 ( * resultado contador ))) (( = contador 0 ) resultado ) ; Condición de detención y valor de retorno. ; El cuerpo del bucle do está vacío. )) | contador factorial | contador := 5 . factorial := 1 .[ contador > 0 ] mientrasTrue: [ factorial := factorial * contador . contador := contador - 1 ] .Transcripción mostrar: factorial printString