En la mayoría de los 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 al menos una vez, y luego ejecuta repetidamente el bloque o deja de ejecutarlo, dependiendo de una condición booleana dada al final del bloque. .
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 y 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 . Debido a que los bucles do while verifican la condición después de que se ejecuta el bloque, la estructura de control a menudo también se conoce como bucle posterior a la prueba . Contraste con el bucle while, que prueba la condición antes de que se ejecute el código dentro del bloque, el ciclo do-while es un ciclo de condición de salida. Esto significa que el código siempre debe ejecutarse primero y luego se evalúa la expresión o condición de prueba. Si es cierto, el código vuelve a ejecutar el cuerpo del bucle. Este proceso se repite siempre que la expresión se evalúe como verdadera. Si la expresión es falsa, el ciclo termina y el control se transfiere a la declaración que sigue al ciclo do-while. En otras palabras, mientras que un bucle while establece la verdad de una declaración como condición previa para la ejecución del código, un bucle do-while proporciona la ejecución en curso de la acción sujeta a anulación por la falsedad de la condición, que falsedad ( es decir , la verdad de la negación de la condición) se establece como una condición posterior .
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 intencionalmente, suele haber otra estructura de control (como una declaración de interrupción ) que permite la terminación del bucle.
Algunos lenguajes pueden usar una convención de nomenclatura diferente para este tipo de bucle. Por ejemplo, los lenguajes Pascal y Lua tienen un ciclo " repetir hasta ", que continúa ejecutándose hasta que la expresión de control es verdadera (y luego termina), mientras que un ciclo "while" se ejecuta mientras la expresión de control es verdadera (y termina una vez que el expresión se vuelve falsa).
Construcciones equivalentes
hacer { do_work (); } while ( condición );
es equivalente a
hacer_trabajo ();while ( condición ) { do_work (); }
De esta manera, el bucle do ... while guarda el "cebado del bucle" inicial do_work();
en la línea antes del while
bucle.
Siempre que no se use la declaración continue , lo anterior es técnicamente equivalente a lo siguiente (aunque estos ejemplos no son el estilo típico o moderno que se usa en las computadoras de todos los días):
while ( verdadero ) { do_work (); si ( ! condición ) se rompe ; }
o
LOOPSTART : do_work (); if ( condición ) goto LOOPSTART ;
Demostrando bucles do while
Estos programas de ejemplo calculan el factorial de 5 usando la sintaxis de sus respectivos lenguajes para un ciclo do-while.
ActionScript 3
contador var : int = 5 ; var factorial : int = 1 ;hacer { factorial * = contador -; / * Multiplica, luego decrementa. * / } while ( contador > 0 );trace ( factorial );
Ada
con Ada.Integer_Text_IO ;procedimiento Factorial es Contador : Entero : = 5 ; Factorial : Entero : = 1 ; comenzar ciclo Factorial : = Factorial * Contador ; Contador : = Contador - 1 ; salir cuando Contador = 0 ; ciclo final ; Ada . Integer_Text_IO . Poner ( factorial ); fin de Factorial ;
BÁSICO
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:
Dim factorial Como Entero Dim contador Como Enterofactorial = 1 contador = 5Hacer factorial = factorial * contador contador = contador - 1 Bucle Mientras contador > 0 Factorial de impresión
C#
int contador = 5 ; int factorial = 1 ;hacer { factorial * = contador -; / * Multiplica, luego decrementa. * / } while ( contador > 0 );Sistema . Consola . WriteLine ( factorial );
C
int contador = 5 ; int factorial = 1 ;hacer { factorial * = contador - ; / * Multiplica, luego decrementa. * / } while ( contador > 0 );printf ( "factorial de 5 es% d \ n " , factorial );
Las sentencias Do-while (0) también se utilizan comúnmente en las macros C como una forma de envolver varias sentencias en una sentencia regular (en contraposición a la compuesta). Hace un punto y coma necesario después de la macro, lo que proporciona una apariencia más funcional para analizadores y programadores simples, además de evitar el problema de alcance con if
. Se recomienda en la regla del estándar de codificación CERT C PRE10-C. [1]
C ++
int contador = 5 ; int factorial = 1 ;hacer { factorial * = contador - ; } while ( contador > 0 );std :: cout << "factorial de 5 es" << factorial << std :: endl ;
CFScript
factorial = 1 ; cuenta = 10 ;hacer { factorial * = contar - ; } while ( cuenta > 1 );writeOutput ( factorial );
D
int contador = 5 ; int factorial = 1 ;hacer { factorial * = contador -; // Multiplica, luego decrementa. } while ( contador > 0 );Writeln ( "factorial de 5 es" , factorial );
Fortran
Con FORTRAN 77 heredado no hay construcción DO-WHILE, pero se puede lograr el mismo efecto con GOTO:
INTEGER CNT , FACT CNT = 5 FACT = 1 1 CONTINUE FACT = FACT * CNT CNT = CNT - 1 IF ( CNT . GT . 0 ) GOTO 1 PRINT * , FACT END
Fortran 90 y versiones posteriores tampoco tienen una construcción do-while, pero tiene una construcción de bucle while que usa las palabras clave "do while" y, por lo tanto, es realmente la misma que la del 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 fin de imprimir * , programa de fin factorial FactorialProg
Java
int contador = 5 ; int factorial = 1 ;hacer { factorial * = contador - ; / * Multiplica, luego decrementa. * / } while ( contador > 0 );Sistema . fuera . println ( "El factorial de 5 es" + factorial );// ============================================ // // La siguiente función hace lo mismo que la anterior. // // ========================================== //int contador = 5 ; int factorial = 1 ;while ( contador > 0 ) { factorial * = contador - ; / * Multiplica, luego decrementa. * / }Sistema . fuera . println ( "El factorial de 5 es" + factorial );
JavaScript
dejar contador = 5 ; // Declarando dos variables, contador y factorial let factorial = 1 ; hacer { factorial * = contador - ; // Qué se repetirá } while ( contador > 0 ); // Las condiciones de bucleconsola . log ( factorial ); // Mostrando el resultado
Kotlin
var counter = 5 var factorial = 1 // Esta línea de código es casi la misma que los códigos JavaScript anteriores, la única diferencia es la palabra clave que muestra los resultados do { factorial * = counter - } while ( counter > 0 )println ( "Factorial de 5 es $ factorial " )
Pascal
Pascal no tiene un do / while; en cambio, tiene una repetición / hasta. Como se mencionó en la introducción, se puede considerar una repetición / hasta que sea equivalente a una construcción 'hacer código sin expresión'.
factorial : = 1 ; contador : = 5 ; repetir factorial : = factorial * contador ; contador : = contador - 1 ; // En Object Pascal se puede usar dec (contador); hasta contador = 0 ;
PHP
$ contador = 5 ; $ factorial = 1 ;hacer { $ factorial * = $ contador - ; } while ( $ contador > 0 );echo $ factorial ;
PL / I
La declaración PL / I DO subsume las funciones del ciclo posterior a la prueba ( hacer hasta ), el ciclo previo a la prueba ( hacer mientras ) y el ciclo for . Todas las funciones se pueden incluir en una sola declaración. El ejemplo muestra solo la sintaxis "hacer hasta".
declarar contador fijo inicial (5);declarar factorial fijo inicial (1);hacer hasta (contador <= 0); factorial = factorial * contador; contador = contador - 1;final;poner (factorial);
Pitón
Python carece de una construcción específica de control de flujo de hacer. Sin embargo, el equivalente se puede construir a partir de un bucle while con una pausa.
contador = 5 factorial = 1while True : factorial * = contador contador - = 1 si contador == 0 : romper imprimir ( factorial )
Raqueta
En Racket, como en otras implementaciones de Scheme , un "named-let" es una forma popular de implementar bucles:
#lang racket ( definir contador 5 ) ( definir factorial 1 ) ( let loop () ( set! factorial ( * contador factorial )) ( set! counter ( contador sub1 )) ( when ( > contador 0 ) ( loop ))) ( displayln factorial )
Compare esto con el primer ejemplo del ejemplo de 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 do adecuado.
( define ( factorial n ) ( do (( contador n ( - contador 1 )) ( resultado 1 ( * contador de resultado ))) (( = contador 0 ) resultado ) ; Condición de parada y valor de retorno .; El cuerpo del do- bucle está vacío. ))
Rubí
contador = 10 factorial = 2comenzar factorial * = contador contador - = 2 final mientras contador > 1pone factorial
Charla
| contador factorial | contador : = 5 . factorial : = 1 .[ contador > 0 ] whileTrue: [ factorial : = factorial * contador . contador : = contador - 1 ] . Demostración de la transcripción : factorial printString
Rápido
Swift 2.xy posterior: [5]
contador var = 5 var factorial = 1repetir { factorial * = contador contador - = 1 } mientras contador > 0imprimir ( factorial )
Swift 1.x:
contador var = 5 var factorial = 1hacer { factorial * = contador contador - = 1 } mientras contador > 0println ( factorial )
Visual Basic .NET
Dim contador Como Entero = 5 Dim factorial Como Entero = 1Hacer factorial * = contador contador - = 1 Bucle mientras contador > 0Consola . WriteLine ( factorial )
Ver también
- Flujo de control
- En bucle
- Para cada
- Repetir bucle (desambiguación)
- Mientras bucle
Referencias
- ^ "C macro de varias líneas: hacer / while (0) vs bloque de alcance" . Desbordamiento de pila .
- ^ "Microsoft visual basic" . msdn.microsoft.com . Consultado el 21 de enero de 2016 .
- ^ "haz ... mientras" . Documentos web de MDN .
- ^ "Control de flujo: si, cuando, para, mientras - Lenguaje de programación Kotlin" . Kotlin .
- ^ "Control de flujo - El lenguaje de programación Swift (Swift 5.3)" . docs.swift.org .
enlaces externos
- hacer {...} while (0) en macros C