Tee silmukan aikana - Do while loop
| Silmukkarakenteet |
|---|
Useimmissa ohjelmointi kieliä, eli tehdä, kun silmukka on kontrollivuotestauksen toteamus , joka suorittaa koodiosion ainakin kerran, ja sitten joko suorittaa toistuvasti estää tai lopettaa sen suorittamista, riippuen tietty boolean ehto lopussa lohkon .
Tehdä, kun konstrukti koostuu menetelmästä symbolin ja kunto. Ensin suoritetaan lohkon sisällä oleva koodi ja sitten ehto arvioidaan. Jos ehto on tosi , lohkon sisäinen koodi suoritetaan uudelleen. Tämä toistuu, kunnes ehto muuttuu vääräksi . Koska "do while" -silmukat tarkistavat kunnon lohkon suorittamisen jälkeen, ohjausrakenne tunnetaan usein myös testin jälkeisenä silmukana . Toisin kuin while-silmukassa , joka testaa ehdon ennen kuin lohkon koodi suoritetaan, do-while -silmukka on exit-condition-silmukka. Tämä tarkoittaa, että koodi on aina suoritettava ensin ja sitten lauseke tai testiehto arvioidaan. Jos se on totta, koodi suorittaa silmukan rungon uudelleen. Tämä prosessi toistetaan niin kauan kuin lauseke on tosi. Jos lauseke on väärä, silmukka päättyy ja ohjaus siirtyy käskyyn do-while -silmukan jälkeen. Toisin sanoen, kun taas while-silmukka asettaa lauseen totuuden ennakkoedellytykseksi koodin suorittamiselle, do-while -silmukka tarjoaa toiminnon käynnissä olevan suorituksen, joka voidaan poistaa ehdon virheellisyyden perusteella, mikä virheellisyys ( ts . Totuus ehdon negaatio) asetetaan seuraavaksi ehdoksi .
On mahdollista ja joissakin tapauksissa toivottavaa, että ehto arvioi aina totta, luo loputon silmukka . Kun tällainen silmukka luodaan tarkoituksella, on yleensä toinen ohjausrakenne (kuten katkaisulauseke ), joka sallii silmukan lopettamisen.
Jotkut kielet saattavat käyttää erilaista nimeämistapaa tämän tyyppiseen silmukkaan. Esimerkiksi Pascal- ja Lua- kielillä on " toista kunnes " -silmukka, joka jatkuu, kunnes ohjauslauseke on totta (ja päättyy sitten) - kun taas "kun" -silmukka kulkee, kun taas ohjauslauseke on totta (ja päättyy, kun lausekkeesta tulee väärä).
Vastaavat rakenteet
do {
do_work();
} while (condition);
vastaa
do_work();
while (condition) {
do_work();
}
Tällä tavoin do ... while -silmukka tallentaa ensimmäisen "silmukan pohjustuksen" silmukkaa do_work();edeltävälle riville while.
Niin kauan kuin jatkaa lausuma ei käytetä, edellä on teknisesti sama kuin jäljempänä (vaikka nämä esimerkit eivät ole tyypillisiä tai moderni tyyli käyttää jokapäiväisessä tietokoneet):
while (true) {
do_work();
if (!condition) break;
}
tai
LOOPSTART:
do_work();
if (condition) goto LOOPSTART;
Osoitetaan, kun tehdään silmukoita
Nämä esimerkkiohjelmat laskevat viiden kertoimen käyttäen vastaavan kielensä syntaksia do-while -silmukalle.
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;
PERUS
Varhaiset BASIC-tiedostot (kuten GW-BASIC ) käyttivät syntaksia WHILE / WEND. Nykyaikaiset BASICit, kuten PowerBASIC, tarjoavat sekä WHILE / WEND- että DO / LOOP-rakenteita, syntaksilla kuten DO WHILE / LOOP, DO UNILIL / LOOP, DO / LOOP WHILE, DO / LOOP UNL ja DO / LOOP (ilman ulompaa testausta, mutta ehdollisella EXIT LOOP: lla jossain silmukan sisällä). Tyypillinen BASIC-lähdekoodi:
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);
Do-while (0) -lausekkeita käytetään myös yleisesti C-makroissa keinona kääriä useita lauseita tavalliseen (toisin kuin yhdistettyyn) lauseeseen. Se tekee makron jälkeen tarvittavasta puolipisteestä, joka tarjoaa toiminnallisemman ulkonäön yksinkertaisille jäsentäjille ja ohjelmoijille sekä välttää laajennusongelman if. Sitä suositellaan CERT C -koodausstandardisäännössä 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
Vanhalla FORTRAN 77: llä ei ole DO-WHILE -rakennetta, mutta sama vaikutus voidaan saavuttaa GOTO: lla:
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: ssä ja uudemmissa ei ole myöskään do-while-rakennetta, mutta sillä on while-silmukkarakenne, joka käyttää avainsanoja "do while" ja on siten itse asiassa sama kuin for -silmukka .
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
Pascalilla ei ole tehtävää / aikaa; sen sijaan sillä on toisto / asti. Kuten johdannossa mainittiin, voidaan katsoa, että toisto / asti vastaa 'do-koodia, kun ei lauseketta' -rakennetta.
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
PL / I DO lausuma subsumes toimintoja jälkeisen testisilmukassa ( siihen asti, kunnes ), ennen testiä silmukka ( tehdä, kun ), ja silmukka . Kaikki toiminnot voidaan sisällyttää yhteen lausekkeeseen. Esimerkki näyttää vain "tee asti" -syntaksin.
declare counter fixed initial(5);
declare factorial fixed initial(1);
do until(counter <= 0);
factorial = factorial * counter;
counter = counter - 1;
end;
put(factorial);
Python
Pythonilta puuttuu tietty tehtävä, kun taas virtauksen ohjausrakenne. Vastaava voidaan kuitenkin rakentaa hetkellisestä silmukasta, jossa on tauko.
counter = 5
factorial = 1
while True:
factorial *= counter
counter -= 1
if counter == 0:
break
print(factorial)
Maila
Racketissä, kuten muissakin Scheme- toteutuksissa, "named-let" on suosittu tapa toteuttaa silmukoita:
#lang racket
(define counter 5)
(define factorial 1)
(let loop ()
(set! factorial (* factorial counter))
(set! counter (sub1 counter))
(when (> counter 0) (loop)))
(displayln factorial)
Vertaa tätä ensimmäiseen esimerkkiin Racketin while loop -esimerkistä. Huomaa, että nimetty let voi myös ottaa argumentteja.
Maila ja kaavio tarjoavat myös oikean do-silmukan.
(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.
))
Rubiini
counter = 10
factorial = 2
begin
factorial *= counter
counter -= 2
end while counter > 1
puts factorial
Rupattelu
| counter factorial |
counter := 5.
factorial := 1.
[counter > 0] whileTrue:
[factorial := factorial * counter.
counter := counter - 1].
Transcript show: factorial printString
Nopea
Swift 2.x ja uudemmat:
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)
