Bucle While

En la mayoría de los lenguajes de programación informática , un bucle while es una sentencia de flujo de control que permite ejecutar código repetidamente en función de una condición booleana determinada . El bucle while puede considerarse como una sentencia if repetitiva .

La construcción while consta de un bloque de código y una condición/expresión. ^[1] La condición/expresión se evalúa y, si la condición/expresión es verdadera , ^[1] se ejecuta el código dentro de todos los que le siguen 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 que se ejecute el bloque, la estructura de control a menudo también se conoce como bucle de pre-prueba . Compárese 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 al {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, se verifica nuevamente la condición (x < 5) y se ejecuta nuevamente el bucle, 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 se crea un bucle de este tipo intencionalmente, suele haber otra estructura de control (como una declaración break ) que controla la finalización del bucle. Por ejemplo:

mientras ( verdadero ) { // hacer cosas complicadas si ( algunaCondición ) romper ; // más cosas }  
    
     
        
    

Estos bucles while calcularán el factorial del número 5:

var contador : int = 5 ; var factorial : int = 1 ;    
    

mientras ( contador > 1 ) { factorial *= contador ; contador --; }    
      
    


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 ; 
    fin  bucle ;

    Ada . Integer_Text_IO . Put  ( Factorial ); 
fin  Factorial ;

contador ← 5 factorial ← 1  
  

: Mientras contador > 0 factorial × ← contador contador - ← 1 : FinMientras   
      
      


⎕ ← factorial  

o simplemente

! 5

contador  :=  5 
factorial  :=  1

Mientras  contador  >  0 
    factorial  *=  contador --

Cuadro de mensaje  %  factorial

contador = 5 ' contador = 5 factorial = 1 ' valor inicial de la variable "factorial"      
    

Mientras contador > 0 factorial = factorial * contador contador = contador - 1 TextWindow . WriteLine ( contador ) EndWhile   
        
        
    

Contador Dim Como Entero = 5 ' inicializar variable y establecer valor. Factorial Dim Como Entero = 1 ' inicializar variable factorial         
       

Hacer Mientras contador > 0 factorial = factorial * contador contador = contador - 1 Bucle ' el programa va aquí, hasta contador = 0    
        
        
     

'Debug.Print factorial' Console.WriteLine(factorial) en Visual Basic .NET

contador = 5 
factorial = 1 
mientras [ $contador -gt 0 ] ; hacer factorial = $(( factorial * contador )) contador = $(( contador - 1 )) hecho      
      
      


eco $factorial 

int main () { int conteo = 5 ; int factorial = 1 ;  
       
       

    mientras ( contar > 1 ) factorial *= contar -- ;   
          

    printf ( "%d" , factorial ); } 

contador  =  5 ; 
factorial  =  1 ;

mientras  ( contador  >  1 )  { 
    factorial  *=  contador -- ; 
}

escribirSalida ( factorial );

<cfset  contador  =  5 > 
<cfset  factorial  =  1 > 
<cfloop  condición = "contador 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 * , factorial fin del programa FactorialProg  

Go no tiene una declaración while , pero tiene la función de una declaración for cuando se omiten 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:

int contador = 5 ; int factorial = 1 ;   
   

mientras ( contador > 1 ) factorial *= contador -- ;   
      

sea ​​contador = 5 ; sea factorial = 1 ;   
   

mientras ( contador > 1 ) factorial *= contador -- ;   
      

consola .log ( factorial ) ;

contador  =  5 
factorial  =  1

mientras  contador  >  0  hacer 
  factorial  =  factorial  *  contador 
  contador  =  contador  -  1 
fin

imprimir ( factorial )

contador = 5 ; factorial = 1 ;  
  

mientras ( contador > 0 ) factorial = factorial * contador ; %Multiplicar contador = contador - 1 ; %Decrementar fin   
              
                        


factorial

Bloque [{ contador = 5 , factorial = 1 }, (*localizar contador y factorial*) While [ contador > 0 , (*bucle While*) factorial *= contador ; (*Multiplicar*) contador -- ; (*Decrementar*) ];  
                
             
                      
    

    factorial 
]

MÓDULO Factorial ; IMPORTAR Salida ; VAR Contador , Factorial : ENTERO ; COMIENZO Contador := 5 ; Factorial := 1 ; 
 

      

      
      

    MIENTRAS Contador > 0 HACER Factorial := Factorial * Contador ; DEC ( Contador ) FIN ;    
            
        
    

    Salida . Int ( Factorial , 0 ) 
FIN Factorial . 

int $contador = 5 ; int $factorial = 1 ;   
   

int $multiplicación ; 

mientras ( $contador > 0 ) { $multiplicación = $factorial * $contador ;    
        

    $contador -= 1 ;  

    print ( "El contador es: " + $contador + ", la multiplicación es: " + $multiplicación + "\n" ); }        

var 
counter = 5 # Establece el valor del contador en 5 factorial = 1 # Establece el valor factorial en 1                
              

mientras contador > 0 : # Mientras contador sea mayor que 0 factorial *= contador # Establezca el nuevo valor de factorial en contador. dec contador # Establezca el contador en contador - 1.          
       
               

factorial de eco 

Bucle while sin terminación:

mientras sea verdadero : echo "¡Ayuda! ¡Estoy atrapado en un bucle!" 
   

Pascal tiene dos formas del bucle while, while y repeat . While repite una instrucción (a menos que esté encerrada en un bloque begin-end) siempre que la condición sea verdadera. La instrucción repeat ejecuta repetidamente un bloque de una o más instrucciones a través de una instrucción till y continúa repitiéndose 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 repeat-until siempre se ejecuta al menos una vez.

programa Factorial1 ; varFv : entero ;​ 

     

    procedimiento hecho ( contador : entero ) ; var Factorial : entero ; 
    
         

    comienza 
Factorial := 1 ;           

         mientras Contador > 0 hacer comenzar Factorial := Factorial * Contador ; Contador := Contador - 1 fin ;    
         
                 
                 
         

         WriteLn ( Factorial ) 
fin ;     

begin 
Write ( 'Ingrese un número para devolver su factorial: ' ) ; readln ( fv ) ; repeat fact ( fv ) ; Write ( 'Ingrese otro número para devolver su factorial (o 0 para salir): ' ) ; hasta fv = 0 ; fin .    
    
    
         
         
      

mi $contador = 5 ; mi $factorial = 1 ;     
   

mientras ( $contador > 0 ) { $factorial *= $contador -- ; # Multiplicar, luego decrementar }    
       


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 IN , "<test.txt" ;  

mientras ( <IN> ) { imprimir ; }  
    


cerrar EN ; 

$contador  =  5 ; 
$factorial  =  1 ;

mientras  ( $contador  >  0 )  { 
    $factorial  *=  $contador -- ;  // Multiplica, luego decrementa. 
}

eco  $factorial ;

declarar  contador    fijo  inicial ( 5 ) ; 
declarar  factorial  fijo  inicial ( 1 ) ;

hacer mientras ( contador > 0 ) factorial = factorial * contador ; contador = contador - 1 ; fin ;   
        
        

contador  =  5                            # Establezca el valor en 5 
factorial  =  1                          # Establezca el valor en 1

mientras  contador  >  0 :                     # Mientras contador(5) sea mayor que 0 
    factorial  *=  contador               # Establezca el nuevo valor de factorial en contador. 
    contador  -=  1                       # Establezca el contador en contador - 1.

print ( factorial )                       # Imprime el valor del factorial.

Bucle while sin terminación:

mientras  True : 
    print ( "¡Ayuda! ¡Estoy atrapado en un bucle!" )

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 () ( when ( > contador 0 ) ( set! factorial ( * factorial contador )) ( set! contador ( sub1 contador )) ( loop ))) ( displayln factorial )  
  
  
       
            
           
        
 

Usando un sistema de macros, implementar un bucle while es un ejercicio trivial (usado comúnmente para introducir macros):

#lang racket 
( define-syntax-rule ( while cuerpo de la prueba ... ) ; implementa un bucle while ( let loop () ( when cuerpo de la prueba ... ( loop )))) ( define contador 5 ) ( define factorial 1 ) ( while ( > contador 0 ) ( set! factorial ( * contador factorial )) ( set! counter ( sub1 contador ))) ( displayln factorial )     
           
  
  
   
        
       
 

Sin embargo, en Scheme y Racket a menudo se desaconseja el estilo de programación imperativo.

# Calcular el factorial de 5 
i = 1 factorial = 1  
  

mientras i <= 5 factorial *= i i += 1 fin   
    
    


pone factorial 

fn  main () { dejar mut contador = 5 ; dejar mut factorial = 1 ; 
        
        

    mientras contador > 1 { factorial *= contador ; contador -= 1 ; }    
          
          
    

    println! ( "{}" , 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 un cierre , utilizando self como condición.

Smalltalk también tiene un método whileFalse: correspondiente.

| count factorial | 
count  :=  5 . 
factorial  :=  1 . 
[ count  >  0 ] whileTrue: 
    [ factorial  :=  factorial  *  count . 
    count  :=  count  -  1 ] . 
Transcripción  mostrar:  factorial

var  counter  =  5                  // Establece el valor del contador inicial en 5 
var  factorial  =  1                // Establece el valor factorial inicial en 1

mientras  contador  >  0  {              // Mientras contador(5) sea mayor que 0 
    factorial  *=  contador         // Establezca el nuevo valor de factorial en factorial x contador. 
    contador  -=  1                 // Establezca el nuevo valor de contador en contador - 1. 
}

print ( factorial )                 // Imprime el valor del factorial.

Establecer  contador 5 Establecer factorial 1 
  

mientras { $contador > 0 } { establecer factorial [expr $factorial * $contador ] incr contador - 1 }    
         
      


pone $factorial 

int contador = 5 ; int factorial = 1 ;   
   

mientras ( contador > 1 ) factorial *= contador -- ;   
      

printf ( "%d" , factorial ); 

$contador  =  5 
$factorial  =  1

mientras  ( $contador )  { 
    $factorial  *=  $contador -- 
}

$factorial

Mientras 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  ( C  >  1 )  hacer 
    F  :=  F  *  C ; 
    C  :=  C  -  1 ;

• Hacer bucle while
• Bucle for
• Para cada uno
• Función recursiva primitiva
• Función recursiva general
• LOOP (lenguaje de programación) : un lenguaje de programación con la propiedad de que las funciones que puede calcular son exactamente las funciones recursivas primitivas.