En muchos lenguajes de programación de computadoras , 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 determinada .
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 verifican la condición después de ejecutar el bloque de código. Esta estructura de control puede conocerse como bucle post-prueba . Esto significa que el ciclo do- while es un ciclo 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 ciclo 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 proporciona 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 intencionalmente un bucle infinito, normalmente existe otra estructura de control que permite la terminación del bucle. Por ejemplo, una declaración de interrupción permitiría la terminación de un bucle infinito.
Algunos idiomas pueden utilizar una convención de nomenclatura 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 es verdadera y luego termina. Por el contrario, un bucle " while " se ejecuta mientras la expresión de control es verdadera y termina una vez que la expresión se vuelve falsa.
hacer { hacer_trabajar (); } mientras ( condición ); es equivalente a
hacer trabajo ();mientras ( condición ) { hacer_trabajar (); } De esta manera, el bucle do... while guarda el "cebado del bucle" inicial do_work();en la línea anterior al whilebucle.
Siempre que no se utilice la instrucción continuar , lo anterior es técnicamente equivalente a lo siguiente (aunque estos ejemplos no son el estilo típico o moderno utilizado en las computadoras cotidianas):
mientras ( verdadero ) { hacer_trabajar (); si ( ! condición ) romper ; } o
LOOPSTART : hacer_trabajo (); si ( condición ) pasa a LOOPSTART ; Estos programas de ejemplo calculan el factorial de 5 usando la sintaxis de sus respectivos idiomas 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 ; bucle final ; Ada . Entero_Texto_IO . Poner ( Factorial ); fin Factorial ;Los primeros BASIC (como GW-BASIC ) usaban 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 BÁSICO típico:
Factorial tenue como entero Contador tenue como entero factorial = 1 contador = 5 Do factorial = factorial * contador contador = contador - 1 Bucle Mientras contador > 0 factorial de impresión contador int = 5 ; entero factorial = 1 ; hacer { factorial *= contador -- ; /* Multiplica y luego disminuye. */ } mientras ( contador > 0 ); printf ( "factorial de 5 es %d \n " , factorial ); Las sentencias Do- while(0) también se utilizan habitualmente en macros de C como una forma de envolver varias sentencias en una sentencia normal (en lugar de una compuesta). Hace que sea necesario un punto y coma después de la macro, proporcionando una apariencia más similar a una función para analizadores y programadores simples, además de evitar el problema de alcance con if. Se recomienda en la regla PRE10-C del estándar de codificación CERT C. [1]
Con Fortran 77 heredado 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 FINAL Fortran 90 y 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, en realidad es lo mismo que el bucle for . [2]
programa FactorialProg entero :: contador = 5 entero :: factorial = 1 factorial = factorial * contador contador = contador - 1 hacer mientras ( contador > 0 ) ! El valor de verdad se prueba antes del ciclo factorial = factorial * contador contador = contador - 1 final do imprimir * , fin del programa factorial FactorialProg contador int = 5 ; entero factorial = 1 ; hacer { factorial *= contador -- ; /* Multiplica y luego disminuye. */ } mientras ( contador > 0 ); Sistema . afuera . println ( "El factorial de 5 es " + factorial ); Pascal usa la sintaxis repetir/hasta en lugar de hacer mientras.
factores := 1 ; contador := 5 ; repetir factorial := factorial * contador ; contador := contador - 1 ; // En Object Pascal se puede usar dec (counter); hasta contador = 0 ; La declaración PL/I DO incluye las funciones del bucle posterior a la prueba ( do Until ), el bucle previo a la prueba ( do while ) y el bucle for . Todas las funciones se pueden incluir en una sola declaración. El ejemplo muestra sólo la sintaxis "hacer hasta".
declarar contador fijo inicial ( 5 ) ;
declarar inicial fija factorial ( 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 raqueta ( definir contador 5 ) ( definir factorial 1 ) ( let loop () ( set! factorial ( * contador factorial )) ( set! contador ( sub1 contador )) ( cuando ( > contador 0 ) ( bucle ))) ( visualización en 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 de ejercicio adecuado.
( define ( factorial n ) ( do (( contador n ( - contador 1 )) ( resultado 1 ( * contador de resultados ))) (( = contador 0 ) resultado ) ; Condición de parada y valor de retorno. ; El cuerpo del do- el bucle está vacío )) | contador factorial | contador : = 5 . factoriales := 1 .[ contador > 0 ] whileTrue: [ factorial := factorial * contador . contador := contador - 1 ] .Mostrar transcripción : printString factorial 