Bucle While

Este artículo necesita citas adicionales para su verificación . Por favor, ayude a mejorar este artículo añadiendo citas de fuentes fiables . El material sin fuentes puede ser cuestionado y eliminado. Buscar fuentes:  «While loop» – noticias  · periódicos  · libros  · académico  · JSTOR ( octubre de 2016 ) ( Aprenda cómo y cuándo eliminar este mensaje )

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, generalmente hay 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 ); 

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

con  Ada.Integer_Text_IO ;procedimiento  Factorial  es  Contador  :  Entero  :=  5 ;  Factorial  :  Entero  :=  1 ; inicio  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  :=  1Mientras  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  =  1mientras  contador  >  0  hacer  factorial  =  factorial  *  contador  contador  =  contador  -  1 finimprimir ( 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 , "<prueba.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 1mientras  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 1mientras  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  =  1mientras  ( $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.