Faça while loop - Do while loop
| Construções de loop |
|---|
Na maioria das linguagens de programação de computador , um loop do while é uma instrução de fluxo de controle que executa um bloco de código pelo menos uma vez e, em seguida, executa repetidamente o bloco ou para de executá-lo, dependendo de uma determinada condição booleana no final do bloco .
A construção do while consiste em um símbolo de processo e uma condição. Primeiro, o código dentro do bloco é executado e, em seguida, a condição é avaliada. Se a condição for verdadeira, o código dentro do bloco é executado novamente. Isso se repete até que a condição se torne falsa . Como os loops do while verificam a condição após a execução do bloco, a estrutura de controle também é conhecida como loop de pós-teste . Em contraste com o loop while , que testa a condição antes que o código dentro do bloco seja executado, o loop do-while é um loop de condição de saída. Isso significa que o código deve sempre ser executado primeiro e, em seguida, a expressão ou condição de teste é avaliada. Se for verdade, o código executa o corpo do loop novamente. Este processo é repetido enquanto a expressão for avaliada como verdadeira. Se a expressão for falsa, o loop termina e o controle é transferido para a instrução após o loop do-while. Em outras palavras, enquanto um loop while define a verdade de uma instrução como uma condição precedente para a execução do código, um loop do-while fornece a execução contínua da ação sujeita a anulação pela falsidade da condição, que é a falsidade ( ou seja , a verdade de a negação da condição) é definida como uma condição subsequente .
É 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 permite o encerramento do loop.
Alguns idiomas podem usar uma convenção de nomenclatura diferente para esse tipo de loop. Por exemplo, as linguagens Pascal e Lua têm um loop " repetir até ", que continua a funcionar até que a expressão de controle seja verdadeira (e então termina) - enquanto um loop "while" é executado enquanto a expressão de controle é verdadeira (e termina quando o expressão torna-se falsa).
Construções equivalentes
do {
do_work();
} while (condition);
é equivalente a
do_work();
while (condition) {
do_work();
}
Dessa maneira, o loop do ... while salva o "priming de loop" inicial do_work();na linha antes do whileloop.
Contanto que a instrução continue não seja usada, o acima é tecnicamente equivalente ao seguinte (embora esses exemplos não sejam de estilo típico ou moderno usado em computadores do dia a dia):
while (true) {
do_work();
if (!condition) break;
}
ou
LOOPSTART:
do_work();
if (condition) goto LOOPSTART;
Demonstrando fazer while loops
Esses programas de exemplo calculam o fatorial de 5 usando a sintaxe de suas respectivas linguagens para um loop do-while.
ActionScript 3
var counter: int = 5;
var factorial: int = 1;
do {
factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);
trace(factorial);
Ada
with Ada.Integer_Text_IO;
procedure Factorial is
Counter : Integer := 5;
Factorial : Integer := 1;
begin
loop
Factorial := Factorial * Counter;
Counter := Counter - 1;
exit when Counter = 0;
end loop;
Ada.Integer_Text_IO.Put (Factorial);
end Factorial;
BASIC
Os primeiros BASICs (como GW-BASIC ) usavam a sintaxe WHILE / WEND. BASICs modernos como PowerBASIC fornecem estruturas WHILE / WEND e DO / LOOP, com sintaxe como DO WHILE / LOOP, DO UNTIL / LOOP, DO / LOOP WHILE, DO / LOOP UNTIL e DO / LOOP (sem testes externos, mas com um EXIT LOOP condicional em algum lugar dentro do loop). Código-fonte BASIC típico:
Dim factorial As Integer
Dim counter As Integer
factorial = 1
counter = 5
Do
factorial = factorial * counter
counter = counter - 1
Loop While counter > 0
Print factorial
C #
int counter = 5;
int factorial = 1;
do {
factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);
System.Console.WriteLine(factorial);
C
int counter = 5;
int factorial = 1;
do {
factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);
printf("factorial of 5 is %d\n", factorial);
As instruções do-while (0) também são comumente usadas em macros C como uma forma de envolver várias instruções em uma instrução regular (em oposição a composta). Ele cria um ponto-e-vírgula necessário após a macro, fornecendo uma aparência mais semelhante a uma função para analisadores e programadores simples, além de evitar o problema de escopo com if. É recomendado no CERT C Coding Standard regra PRE10-C.
C ++
int counter = 5;
int factorial = 1;
do {
factorial *= counter--;
} while (counter > 0);
std::cout << "factorial of 5 is "<< factorial << std::endl;
CFScript
factorial = 1;
count = 10;
do {
factorial *= count--;
} while (count > 1);
writeOutput(factorial);
D
int counter = 5;
int factorial = 1;
do {
factorial *= counter--; // Multiply, then decrement.
} while (counter > 0);
writeln("factorial of 5 is ", factorial);
Fortran
Com o FORTRAN 77 legado, não há construção DO-WHILE, mas o mesmo efeito pode ser alcançado com 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
O Fortran 90 e posterior também não tem uma construção do-while, mas tem uma construção de loop while que usa as palavras-chave "do while" e é, portanto, na verdade o mesmo que o loop for .
program FactorialProg
integer :: counter = 5
integer :: factorial = 1
factorial = factorial * counter
counter = counter - 1
do while (counter > 0) ! Truth value is tested before the loop
factorial = factorial * counter
counter = counter - 1
end do
print *, factorial
end program FactorialProg
Java
int counter = 5;
int factorial = 1;
do {
factorial *= counter--; /* Multiply, then decrement. */
} while (counter > 0);
System.out.println("The factorial of 5 is " + factorial);
//============================================//
// The below function does the same as above. //
//============================================//
int counter = 5;
int factorial = 1;
while (counter > 0){
factorial *= counter--; /* Multiply, then decrement. */
}
System.out.println("The factorial of 5 is " + factorial);
JavaScript
let counter = 5; // Declaring two variables, counter and factorial
let factorial = 1;
do {
factorial *= counter--; //What will be looped
} while (counter > 0); //The looping conditions
console.log(factorial); //Showing the result
Kotlin
var counter = 5
var factorial = 1
//These line of code is almost the same as the above JavaScript codes, the only difference is the keyword that shows the results
do {
factorial *= counter--
} while (counter > 0)
println("Factorial of 5 is $factorial")
Pascal
Pascal não tem do / while; em vez disso, ele tem um repeat / until. Conforme mencionado na introdução, pode-se considerar um repeat / until equivalente a uma construção 'do code while not expression'.
factorial := 1;
counter := 5;
repeat
factorial := factorial * counter;
counter := counter - 1; // In Object Pascal one may use dec (counter);
until counter = 0;
PHP
$counter = 5;
$factorial = 1;
do {
$factorial *= $counter--;
} while ($counter > 0);
echo $factorial;
PL / I
A instrução PL / I DO inclui as funções do loop de pós-teste ( do until ), do loop de pré-teste ( do while ) e do loop for . Todas as funções podem ser incluídas em uma única instrução. O exemplo mostra apenas a sintaxe "do until".
declare counter fixed initial(5);
declare factorial fixed initial(1);
do until(counter <= 0);
factorial = factorial * counter;
counter = counter - 1;
end;
put(factorial);
Pitão
Python carece de uma construção de controle de fluxo específica do while. No entanto, o equivalente pode ser construído a partir de um loop while com uma pausa.
counter = 5
factorial = 1
while True:
factorial *= counter
counter -= 1
if counter == 0:
break
print(factorial)
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 ()
(set! factorial (* factorial counter))
(set! counter (sub1 counter))
(when (> counter 0) (loop)))
(displayln factorial)
Compare isso com o primeiro exemplo do exemplo de loop while para Racket. Esteja ciente de que um let nomeado também pode receber argumentos.
Racket e Scheme também fornecem um loop do adequado.
(define (factorial n)
(do ((counter n (- counter 1))
(result 1 (* result counter)))
((= counter 0) result) ; Stop condition and return value.
; The body of the do-loop is empty.
))
Rubi
counter = 10
factorial = 2
begin
factorial *= counter
counter -= 2
end while counter > 1
puts factorial
Conversa fiada
| counter factorial |
counter := 5.
factorial := 1.
[counter > 0] whileTrue:
[factorial := factorial * counter.
counter := counter - 1].
Transcript show: factorial printString
Rápido
Swift 2.xe posterior:
var counter = 5
var factorial = 1
repeat {
factorial *= counter
counter -= 1
} while counter > 0
print(factorial)
Swift 1.x:
var counter = 5
var factorial = 1
do {
factorial *= counter
counter -= 1
} while counter > 0
println(factorial)
Visual Basic .NET
Dim counter As Integer = 5
Dim factorial As Integer = 1
Do
factorial *= counter
counter -= 1
Loop While counter > 0
Console.WriteLine(factorial)