Hacer bucle while

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 utilizar una convención de nombres diferente para este tipo de bucle. Por ejemplo, los lenguajes Pascal y Lua tienen un bucle " repeat till ", que continúa ejecutándose hasta que la expresión de control sea verdadera y luego finaliza. Por el contrario, un bucle "while" se ejecuta mientras la expresión de control sea verdadera y finaliza una vez que la expresión se vuelve falsa.

hacer { hacer_trabajo (); } mientras ( condición );    

es equivalente a

hacer_trabajo ();mientras ( condición ) { hacer_trabajo (); }   

De esta manera, el bucle do... while guarda la "preparación 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 ;     

This section's factual accuracy is disputed. Relevant discussion may be found on the talk page. Please help to ensure that disputed statements are reliably sourced. (November 2020) (Learn how and when to remove this message)

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 ) ;

Python no tiene un bucle DO-WHILE, pero su efecto se puede lograr mediante un bucle infinito con una condición de ruptura al final.

factorial  =  1 contador  =  5mientras sea  verdadero :  factorial  *=  contador contador  -  =  1  si  contador  <  1 :  romperimprimir ( 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

• Flujo de control
• Bucle for
• Bucle foreach
• Repetir bucle (desambiguación)
• Bucle While

El Wikilibro Ada Programming tiene una página sobre el tema: Control

• hacer {...} mientras (0) en macros C