Loop while - While loop
Construções de loop |
---|
Na maioria das linguagens de programação de computador, um loop while é uma instrução de fluxo de controle que permite que o código seja executado repetidamente com base em uma determinada condição booleana . A enquanto loop pode ser pensado como um repetindo if .
Visão geral
A construção while consiste em um bloco de código e uma condição / expressão. A condição / expressão é avaliada e, se a condição / expressão for verdadeira , o código dentro de todos os seguintes no bloco é executado. Isso se repete até que a condição / expressão se torne falsa . Porque os enquanto os controlos de circuito da condição / expressão antes do bloco é executado, a estrutura de controlo é muitas vezes também conhecido como um circuito de pré-teste . Compare isso com o loop do while , que testa a condição / expressão após a execução do loop.
Por exemplo, na linguagem de programação C (bem como Java , C # , Objective-C e C ++ , que usam a mesma sintaxe neste caso), o fragmento de código
int x = 0;
while (x < 5) {
printf ("x = %d\n", x);
x++;
}
primeiro verifica se x é menor que 5, o que é, então o {corpo do loop} é inserido, onde a função printf é executada e x é incrementado em 1. Depois de completar todas as instruções no corpo do loop, a condição, ( x <5), é verificado novamente, e o loop é executado novamente, este processo se repetindo até que a variável x tenha o valor 5.
Observe que é possível, e em alguns casos desejável, que a condição sempre seja avaliada como verdadeira, criando um loop infinito . Quando esse loop é criado intencionalmente, geralmente há outra estrutura de controle (como uma instrução break ) que controla o término do loop. Por exemplo:
while (true) {
// do complicated stuff
if (someCondition)
break;
// more stuff
}
Demonstrando while loops
Esses loops while irão calcular o fatorial do número 5:
ActionScript 3
var counter: int = 5;
var factorial: int = 1;
while (counter > 1) {
factorial *= counter;
counter--;
}
Printf("Factorial = %d", factorial);
Ada
with Ada.Integer_Text_IO;
procedure Factorial is
Counter : Integer := 5;
Factorial : Integer := 1;
begin
while Counter > 0 loop
Factorial := Factorial * Counter;
Counter := Counter - 1;
end loop;
Ada.Integer_Text_IO.Put (Factorial);
end Factorial;
AutoHotkey
counter := 5
factorial := 1
While counter > 0
factorial *= counter--
MsgBox % factorial
Microsoft Small Basic
counter = 5 ' Counter = 5
factorial = 1 ' initial value of variable "factorial"
While counter > 0
factorial = factorial * counter
counter = counter - 1
TextWindow.WriteLine(counter)
EndWhile
Visual básico
Dim counter As Integer = 5 ' init variable and set value
Dim factorial As Integer = 1 ' initialize factorial variable
Do While counter > 0
factorial = factorial * counter
counter = counter - 1
Loop ' program goes here, until counter = 0
'Debug.Print factorial ' Console.WriteLine(factorial) in Visual Basic .NET
Shell Bourne (Unix)
counter=5
factorial=1
while [ $counter -gt 0 ]; do
factorial=$((factorial * counter))
counter=$((counter - 1))
done
echo $factorial
C ou C ++
int main() {
int counter = 5;
int factorial = 1;
while (counter > 1)
factorial *= counter--;
printf("%d", factorial);
}
CFML
Sintaxe do script
counter = 5;
factorial = 1;
while (counter > 1) {
factorial *= counter--;
}
writeOutput(factorial);
Sintaxe de tag
<cfset counter = 5>
<cfset factorial = 1>
<cfloop condition="counter GT 1">
<cfset factorial *= counter-->
</cfloop>
<cfoutput>#factorial#</cfoutput>
Fortran
program FactorialProg
integer :: counter = 5
integer :: factorial = 1
do while (counter > 0)
factorial = factorial * counter
counter = counter - 1
end do
print *, factorial
end program FactorialProg
Ir
Go não tem uma instrução whiile, mas tem a função de uma instrução for se você omitir alguns elementos da instrução for.
counter, factorial := 5, 1
for counter > 1 {
counter, factorial = counter-1, factorial*counter
}
Java , C # , D
O código do loop é o mesmo para Java, C # e D:
int counter = 5;
int factorial = 1;
while (counter > 1)
factorial *= counter--;
JavaScript
let counter = 5;
let factorial = 1;
while (counter > 1)
factorial *= counter--;
console.log(factorial);
Lua
counter = 5
factorial = 1
while counter > 0 do
factorial = factorial * counter
counter = counter - 1
end
print(factorial)
MATLAB e GNU Octave
counter = 5;
factorial = 1;
while (counter > 0)
factorial = factorial * counter; %Multiply
counter = counter - 1; %Decrement
end
factorial
Mathematica
Block[{counter=5,factorial=1}, (*localize counter and factorial*)
While[counter>0, (*While loop*)
factorial*=counter; (*Multiply*)
counter--; (*Decrement*)
];
factorial
]
Oberon , Oberon-2 (linguagem de programação) , Oberon-07 ou Component Pascal
MODULE Factorial;
IMPORT Out;
VAR
Counter, Factorial: INTEGER;
BEGIN
Counter := 5;
Factorial := 1;
WHILE Counter > 0 DO
Factorial := Factorial * Counter;
DEC(Counter)
END;
Out.Int(Factorial,0)
END Factorial.
Maya Embedded Language
int $counter = 5;
int $factorial = 1;
int $multiplication;
while ($counter > 0) {
$multiplication = $factorial * $counter;
$counter -= 1;
print("Counter is: " + $counter + ", multiplication is: " + $multiplication + "\n");
}
Nim
var
counter = 5 # Set counter value to 5
factorial = 1 # Set factorial value to 1
while counter > 0: # While counter is greater than 0
factorial *= counter # Set new value of factorial to counter.
dec counter # Set the counter to counter - 1.
echo factorial
Loop while sem terminação:
while true:
echo "Help! I'm stuck in a loop!"
Pascal
Pascal tem duas formas de loop while, while e repeat . Enquanto repete uma instrução (a menos que esteja dentro de um bloco de início e fim), desde que a condição seja verdadeira. A instrução repeat executa repetidamente um bloco de uma ou mais instruções por meio de uma instrução until e continua repetindo, a menos que a condição seja falsa. A principal diferença entre os dois é que o loop while pode ser executado zero vezes se a condição for inicialmente falsa, o loop repeat-until sempre é executado pelo menos uma vez.
program Factorial1;
var
Fv: integer;
procedure fact(counter:integer);
var
Factorial: integer;
begin
Factorial := 1;
while Counter > 0 do
begin
Factorial := Factorial * Counter;
Counter := Counter - 1
end;
WriteLn(Factorial)
end;
begin
Write('Enter a number to return its factorial: ');
readln(fv);
repeat
fact(fv);
Write('Enter another number to return its factorial (or 0 to quit): ');
until fv=0;
end.
Perl
my $counter = 5;
my $factorial = 1;
while ($counter > 0) {
$factorial *= $counter--; # Multiply, then decrement
}
print $factorial;
Embora os loops sejam freqüentemente usados para ler dados linha por linha (conforme definido pelo $/
separador de linha) de manipuladores de arquivos abertos:
open IN, "<test.txt";
while (<IN>) {
print;
}
close IN;
PHP
$counter = 5;
$factorial = 1;
while ($counter > 0) {
$factorial *= $counter--; // Multiply, then decrement.
}
echo $factorial;
PL / I
declare counter fixed initial(5);
declare factorial fixed initial(1);
do while(counter > 0)
factorial = factorial * counter;
counter = counter - 1;
end;
Pitão
counter = 5 # Set the value to 5
factorial = 1 # Set the value to 1
while counter > 0: # While counter(5) is greater than 0
factorial *= counter # Set new value of factorial to counter.
counter -= 1 # Set the counter to counter - 1.
print(factorial) # Print the value of factorial.
Loop while sem terminação:
while True:
print("Help! I'm stuck in a loop!")
Raquete
No Racket, como em outras implementações de Scheme , um named-let é uma maneira popular de implementar loops:
#lang racket
(define counter 5)
(define factorial 1)
(let loop ()
(when (> counter 0)
(set! factorial (* factorial counter))
(set! counter (sub1 counter))
(loop)))
(displayln factorial)
Usando um sistema de macro, a implementação de um enquanto laço é um exercício trivial (comumente usado para introduzir macros):
#lang racket
(define-syntax-rule (while test body ...) ; implements a while loop
(let loop () (when test body ... (loop))))
(define counter 5)
(define factorial 1)
(while (> counter 0)
(set! factorial (* factorial counter))
(set! counter (sub1 counter)))
(displayln factorial)
Mas note que um estilo de programação imperativo é freqüentemente desencorajado no Racket (como no Scheme).
Rubi
# Calculate the factorial of 5
i = 1
factorial = 1
while i <= 5
factorial *= i
i += 1
end
puts factorial
Ferrugem
fn main() {
let mut counter = 5;
let mut factorial = 1;
while counter > 1 {
factorial *= counter;
counter -= 1;
}
println!("{}", factorial);
}
Conversa fiada
Ao contrário de outras línguas, em Smalltalk uma enquanto loop não é uma construção de linguagem mas definido na classe BlockClosure
como um método com um parâmetro, o corpo como um fecho , utilizando auto como a condição.
Smalltalk também possui um método whileFalse: correspondente.
| count factorial |
count := 5.
factorial := 1.
[count > 0] whileTrue:
[factorial := factorial * count.
count := count - 1].
Transcript show: factorial
Rápido
var counter = 5 // Set the initial counter value to 5
var factorial = 1 // Set the initial factorial value to 1
while counter > 0 { // While counter(5) is greater than 0
factorial *= counter // Set new value of factorial to factorial x counter.
counter -= 1 // Set the new value of counter to counter - 1.
}
print(factorial) // Print the value of factorial.
Tcl
set counter 5
set factorial 1
while {$counter > 0} {
set factorial [expr $factorial * $counter]
incr counter -1
}
puts $factorial
VEX
int counter = 5;
int factorial = 1;
while (counter > 1)
factorial *= counter--;
printf("%d", factorial);
PowerShell
$counter = 5
$factorial = 1
while ($counter) {
$factorial *= $counter--
}
$factorial
Enquanto linguagem de programação
A linguagem de programação While é uma linguagem de programação simples construída a partir de atribuições, composição sequencial, condicionais e instruções while, usada na análise teórica da semântica da linguagem de programação imperativa .
C := 5;
F := 1;
while (C > 1) do
F := F * C;
C := C - 1;
Veja também
- Faça while loop
- For loop
- Para cada
- LOOP (linguagem de programação) - uma linguagem de programação com a propriedade de que as funções que pode calcular são exatamente as funções recursivas primitivas