Do while loop - Do while loop
| Hurok konstrukciók |
|---|
A legtöbb számítógépes programozási nyelvben a do while ciklus egy vezérlési folyamat utasítás , amely legalább egyszer végrehajt egy kódblokkot, majd a blokkot többször végrehajtja, vagy leállítja annak végrehajtását, a blokk végén megadott logikai feltételektől függően. .
A do while konstrukció egy folyamat szimbólumból és egy feltételből áll. Először a blokkon belüli kódot hajtják végre, majd értékelik a feltételt. Ha a feltétel igaz , akkor a blokkon belüli kód ismét végrehajtásra kerül. Ez addig ismétlődik, amíg a feltétel hamis nem lesz . Mivel a do while ciklusok ellenőrzik az állapotot a blokk végrehajtása után, a vezérlő struktúrát gyakran post-test ciklusnak is nevezik . Kontrasztban van a while ciklussal , amely a blokkon belüli kód végrehajtása előtt teszteli a feltételt, a do-while ciklus egy exit-feltétel ciklus. Ez azt jelenti, hogy először mindig a kódot kell végrehajtani, majd kiértékelni a kifejezést vagy a tesztfeltételt. Ha igaz, akkor a kód újra végrehajtja a hurok törzsét. Ezt a folyamatot addig ismételjük, amíg a kifejezés igaznak bizonyul. Ha a kifejezés hamis, akkor a hurok befejeződik, és a vezérlés átkerül a do-while ciklust követő utasításba. Más szavakkal, míg a while ciklus az utasítás igazságát feltételként szabja meg a kód végrehajtásának előfeltételeként , a do-while ciklus a művelet folyamatban lévő végrehajtását írja elő, amelyet a feltétel valótlansága ( azaz a az állapot a tagadás) van beállítva, mint egy feltétel későbbi .
Lehetséges, és bizonyos esetekben kívánatos, hogy az állapot mindig igaz legyen, és végtelen ciklust hozzon létre . Amikor egy ilyen hurok szándékosan jön létre, általában van egy másik vezérlő struktúra (például egy break utasítás ), amely lehetővé teszi a hurok befejezését.
Egyes nyelvek eltérő elnevezési szokásokat használhatnak az ilyen típusú hurkokhoz. Például a Pascal és a Lua nyelvnek van egy " ismételgetés " huroka, amely addig fut, amíg a vezérlő kifejezés igaz (majd leáll) - míg a "míg" hurok fut, míg a vezérlő kifejezés igaz (és akkor fejeződik be, amikor a kifejezés hamissá válik).
Ekvivalens konstrukciók
do {
do_work();
} while (condition);
egyenértékű
do_work();
while (condition) {
do_work();
}
Ily módon a do ... while hurok elmenti a kezdeti "hurok alapozást" do_work();a whileciklus előtti vonalon .
Mindaddig, amíg a folytatás utasítást nem használják, a fentiek technikailag egyenértékűek az alábbiakkal (bár ezek a példák nem tipikusak vagy modern stílusúak a mindennapi számítógépekben):
while (true) {
do_work();
if (!condition) break;
}
vagy
LOOPSTART:
do_work();
if (condition) goto LOOPSTART;
A do while ciklusok bemutatása
Ezek a példa programok kiszámítják az 5 tényezőjét a saját nyelvük szintaxisának felhasználásával a do-while ciklushoz.
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;
ALAPVETŐ
A korai BASIC- ok (például a GW-BASIC ) a WHOT / WEND szintaxist használták. A modern BASIC-ok, mint például a PowerBASIC, mind a WHILE / WEND, mind a DO / LOOP struktúrákat olyan szintaxissal látják el, mint a DO WHILE / LOOP, DO UNIL / LOOP, DO / LOOP WHILE, DO / LOOP UNIL és DO / LOOP (külső tesztelés nélkül, de feltételes EXIT LOOP-val valahol a hurok belsejében). Tipikus BASIC forráskó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);
A Do-while (0) utasításokat a C makrókban is gyakran használják, hogy több állítást szabályos (szemben az összetett) utasításba csomagolhassanak. Vessünk pontosvesszőt a makró után, amely funkciószerűbb megjelenést biztosít az egyszerű elemzők és programozók számára, valamint elkerüli a hatókör átfogási problémáját if. A CERT C kódolási szabvány PRE10-C szabályában ajánlott.
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
A régi FORTRAN 77 esetében nincs DO-WHILE konstrukció, de ugyanaz a hatás érhető el a GOTO használatával:
INTEGER CNT,FACT
CNT=5
FACT=1
1 CONTINUE
FACT=FACT*CNT
CNT=CNT-1
IF (CNT.GT.0) GOTO 1
PRINT*,FACT
END
A Fortran 90-es és későbbi verzióiban sincs do-while konstrukció, de van egy darab loop- konstrukciója, amely a "do while" kulcsszavakat használja, és így valójában megegyezik a for ciklussal .
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
Pascalnak nincs tennivalója / ideje; ehelyett van egy ismétlés / ig. Amint a bevezetőben említettük, az ismétlés / ig egyenértékűnek tekinthető a 'do kód, míg nem kifejezés' konstrukcióval.
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 PL / I DO utasítás alátámasztja a teszt utáni ciklus ( do amíg ), az előteszt ciklus ( do while ) és a for ciklus funkcióit . Minden függvény egyetlen utasításban szerepelhet. A példa csak a "do till" szintaxist mutatja.
declare counter fixed initial(5);
declare factorial fixed initial(1);
do until(counter <= 0);
factorial = factorial * counter;
counter = counter - 1;
end;
put(factorial);
Piton
A Pythonból hiányzik egy adott művelet, míg az áramlásvezérlő konstrukció. Az egyenérték azonban megépíthető egy darab hurokból, szakítással.
counter = 5
factorial = 1
while True:
factorial *= counter
counter -= 1
if counter == 0:
break
print(factorial)
Ütő
Az Racket-ben, akárcsak a többi Scheme- megvalósításban, a "named-let" a hurkok megvalósításának népszerű módja:
#lang racket
(define counter 5)
(define factorial 1)
(let loop ()
(set! factorial (* factorial counter))
(set! counter (sub1 counter))
(when (> counter 0) (loop)))
(displayln factorial)
Hasonlítsa ezt össze a Racket while loop példájával. Ne feledje, hogy egy megnevezett let is érvelhet.
Az ütő és a séma megfelelő do ciklust is biztosít.
(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.
))
Rubin
counter = 10
factorial = 2
begin
factorial *= counter
counter -= 2
end while counter > 1
puts factorial
Csevej
| counter factorial |
counter := 5.
factorial := 1.
[counter > 0] whileTrue:
[factorial := factorial * counter.
counter := counter - 1].
Transcript show: factorial printString
Gyors
Swift 2.x és újabb:
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)
