Proveďte smyčku while - Do while loop
| Smyčkové konstrukty |
|---|
Ve většině počítačových programovacích jazyků, je dělat, zatímco smyčka je řízení toku prohlášení , které vykonává blok kódu alespoň jednou, a pak buď opakovaně vykonává blok, nebo zastaví provádění to v závislosti na dané logickou podmínkou na konci bloku .
Konstrukce do while se skládá ze symbolu procesu a podmínky. Nejprve se provede kód v bloku a poté se vyhodnotí podmínka. Pokud je podmínka pravdivá, kód v bloku se provede znovu. To se opakuje, dokud se podmínka nestane nepravdivou . Protože smyčky do while kontrolují stav po provedení bloku, je kontrolní struktura často známá také jako smyčka po testu . Kontrast se smyčkou while , která testuje podmínku před provedením kódu v bloku, smyčka do-while je smyčka podmínky ukončení. To znamená, že kód musí být vždy proveden jako první a poté je vyhodnocen výraz nebo testovací podmínka. Pokud je to pravda, kód provede tělo smyčky znovu. Tento proces se opakuje, dokud se výraz vyhodnotí jako true. Pokud je výraz nepravdivý, smyčka se ukončí a řídí přenosy do příkazu následujícího po smyčce do-while. Jinými slovy, zatímco smyčka while nastavuje pravdivost příkazu jako precedenční podmínku pro provedení kódu, smyčka do-while poskytuje probíhající provádění akce, která je předmětem defeasance falešností podmínky, což je faleš ( tj . Pravdivost negace podmínky) je nastavena jako podmínka následující .
Je možné a v některých případech žádoucí, aby podmínka byla vždy vyhodnocena jako true, čímž se vytvoří nekonečná smyčka . Když je taková smyčka vytvořena záměrně, obvykle existuje další řídicí struktura (například příkaz break ), která umožňuje ukončení smyčky.
Některé jazyky mohou pro tento typ smyčky použít jinou konvenci pojmenování. Například jazyky Pascal a Lua mají smyčku „ opakovat do “, která pokračuje v běhu, dokud není řídicí výraz pravdivý (a poté se ukončí) - zatímco smyčka „while“ běží, zatímco kontrolní výraz je pravdivý (a končí se jednou výraz se stane nepravdivým).
Ekvivalentní konstrukty
do {
do_work();
} while (condition);
je ekvivalentní k
do_work();
while (condition) {
do_work();
}
Tímto způsobem smyčka do ... while uloží počáteční "priming smyčky" s do_work();na řádek před whilesmyčkou.
Pokud se nepoužije příkaz continue , výše uvedené je technicky ekvivalentní následujícímu (i když tyto příklady nejsou typickým nebo moderním stylem používaným v běžných počítačích):
while (true) {
do_work();
if (!condition) break;
}
nebo
LOOPSTART:
do_work();
if (condition) goto LOOPSTART;
Demonstrace dělat zatímco smyčky
Tyto ukázkové programy vypočítají faktoriál 5 pomocí syntaxe příslušných jazyků pro smyčku 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;
ZÁKLADNÍ
Early BASICs (například GW-BASIC ) používaly syntaxi WHILE / WEND. Moderní ZÁKLADY, jako je PowerBASIC, poskytují struktury WHILE / WEND a DO / LOOP se syntaxí jako DO WHILE / LOOP, DO UNTIL / LOOP, DO / LOOP WHILE, DO / LOOP UNTIL a DO / LOOP (bez vnějšího testování, ale s podmíněným EXIT LOOP někde uvnitř smyčky). Typický ZÁKLADNÍ zdrojový kód:
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);
Příkazy do-while (0) se také běžně používají v makrech C jako způsob, jak zabalit více příkazů do běžného (na rozdíl od složeného) příkazu. Vytvoří středník potřebný po makru, který poskytuje funkčnější vzhled pro jednoduché analyzátory a programátory a vyhne se problému s rozsahem if. Doporučuje se to v pravidle CERT C Coding Standard 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
Se starým FORTRANem 77 neexistuje konstrukce DO-WHILE, ale stejného efektu lze dosáhnout s 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 a novější také nemá konstrukt do-while, ale má konstrukt smyčky while, který používá klíčová slova „do while“ a je tedy ve skutečnosti stejný jako smyčka 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
Jáva
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 nemá do / while; místo toho má opakování / do. Jak již bylo zmíněno v úvodu, lze považovat opakování / do za ekvivalent konstruktu '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.
Příkaz PL / I DO zahrnuje funkce smyčky po testu ( do ), smyčky před testem ( do while ) a smyčky for . Všechny funkce lze zahrnout do jednoho příkazu. Příklad ukazuje pouze syntaxi „do“.
declare counter fixed initial(5);
declare factorial fixed initial(1);
do until(counter <= 0);
factorial = factorial * counter;
counter = counter - 1;
end;
put(factorial);
Krajta
Python postrádá konkrétní konstrukci při řízení toku. Ekvivalent však může být sestaven ze smyčky while s přestávkou.
counter = 5
factorial = 1
while True:
factorial *= counter
counter -= 1
if counter == 0:
break
print(factorial)
Raketa
V raketě, stejně jako v jiných implementacích schémat , je „pojmenovaný let“ populární způsob implementace smyček:
#lang racket
(define counter 5)
(define factorial 1)
(let loop ()
(set! factorial (* factorial counter))
(set! counter (sub1 counter))
(when (> counter 0) (loop)))
(displayln factorial)
Porovnejte to s prvním příkladem příkladu smyčky while pro Racket. Uvědomte si, že pojmenovaný let může také přijímat argumenty.
Racket and Scheme také poskytují správnou smyčku do.
(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.
))
Rubín
counter = 10
factorial = 2
begin
factorial *= counter
counter -= 2
end while counter > 1
puts factorial
Pokec
| counter factorial |
counter := 5.
factorial := 1.
[counter > 0] whileTrue:
[factorial := factorial * counter.
counter := counter - 1].
Transcript show: factorial printString
Rychlý
Swift 2.x a novější:
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)