Gör while loop
Slingkonstruktioner |
---|
I de flesta datorprogrammeringsspråk är en do while loop en kontrollflödessats som exekverar ett kodblock och sedan antingen upprepar blocket eller lämnar loopen beroende på ett givet booleskt tillstånd .
Do while- konstruktionen består av en processsymbol och ett villkor. Först exekveras koden i blocket. Därefter utvärderas tillståndet. Om villkoret är sant exekveras koden i blocket igen. Detta upprepas tills tillståndet blir falskt .
Gör medan loopar kontrollera tillståndet efter att kodblocket exekveras. Denna kontrollstruktur kan kallas en post-test loop . Detta betyder att do-while-slingan är en utgångs-tillståndsslinga. En while loop kommer dock att testa villkoret innan koden i blocket exekveras.
Detta innebär att koden alltid exekveras först och sedan utvärderas uttrycket eller testvillkoret. Denna process upprepas så länge uttrycket utvärderas till sant. Om uttrycket är falskt avslutas loopen. En while-loop ställer in sanningen i ett påstående som ett nödvändigt villkor för kodens exekvering. En do-while loop ger åtgärdens pågående exekvering tills villkoret inte längre är sant.
Det är möjligt och ibland önskvärt att tillståndet alltid bedöms vara sant. Detta skapar en oändlig loop . När en oändlig loop skapas avsiktligt finns det vanligtvis en annan kontrollstruktur som tillåter avslutning av loopen. Till exempel skulle en break-sats tillåta avslutning av en oändlig loop.
Vissa språk kan använda en annan namnkonvention för den här typen av loop. Till exempel Pascal- och Lua -språken en " upprepa tills "-loop, som fortsätter att köras tills kontrolluttrycket är sant och sedan avslutas. Däremot körs en "while"-loop medan kontrolluttrycket är sant och avslutas när uttrycket blir falskt.
Motsvarande konstruktioner
gör { gör_arbete (); } while ( villkor );
är ekvivalent med
göra_arbete (); while ( villkor ) { gör_arbete (); }
På det här sättet sparar do ... while loop den initiala "loop priming" med do_work();
på linjen före while-
slingan.
Så länge fortsätt -satsen inte används är ovanstående tekniskt likvärdigt med följande (även om dessa exempel inte är typiska eller moderna som används i vanliga datorer):
while ( sant ) { gör_arbete (); om ( ! skick ) bryta ; }
eller
LOOPSTART : do_work (); if ( villkor ) goto LOOPSTART ;
Demonstrerar do while loopar
Dessa exempelprogram beräknar faktorvärdet 5 med hjälp av deras respektive språks syntax för en do-while loop.
ActionScript 3
0
var räknare : int = 5 ; var factorial : int = 1 ; gör { faktoriell *= räknare --; /* Multiplicera och minska sedan. */ } while ( räknare > ); spåra ( faktoriellt );
Ada
0
med Ada.Integer_Text_IO ; procedur Faktoriell är Räknare : Heltal := 5 ; Faktoriell : Heltal := 1 ; börja loop Faktoriell := Faktoriell * Räknare ; Räknare := Räknare - 1 ; avsluta när Counter = ; ändslinga ; _ Ada . Integer_Text_IO . Sätt ( Faktoriell ); slut Faktoriell ;
GRUNDLÄGGANDE
Tidiga BASICs (som GW-BASIC ) använde syntaxen WHILE/WEND. Moderna BASICs som PowerBASIC tillhandahåller både WHILE/WEND och DO/LOOP strukturer, med syntax som DO WHILE/LOOP, DO UNTIL/LOOP, DO/LOOP WHILE, DO/LOOP TILL och DO/LOOP (utan yttre testning, men med en villkorad EXIT LOOP någonstans inuti slingan). Typisk BASIC källkod:
Dimfaktoriell Som heltal Dimräknare Som heltal faktoriell = 1 räknare = 5 Do faktoriell = faktoriell * räknarräknare = räknare - 1 slinga Medan räknare > Skriv ut faktoriell _ _
0
C#
0
int räknare = 5 ; int factorial = 1 ; gör { faktoriell *= räknare --; /* Multiplicera och minska sedan. */ } while ( räknare > ); System . Konsol . WriteLine ( faktoriell );
C
0
int räknare = 5 ; int factorial = 1 ; do { faktoriell *= räknare -- ; /* Multiplicera och minska sedan. */ } while ( räknare > ); printf ( "faktor 5 är %d \n " , faktoriell );
Do-while(0)-satser används också ofta i C-makron som ett sätt att slå in flera satser till en vanlig (i motsats till sammansatt) sats. Det gör ett semikolon som behövs efter makrot, vilket ger ett mer funktionsliknande utseende för enkla analyserare och programmerare samt undviker omfattningsproblemet med if
. Det rekommenderas i CERT C kodningsstandardregel PRE10-C.
C++
0
int räknare = 5 ; int factorial = 1 ; do { faktoriell *= räknare -- ; } while ( räknare > ); std :: cout << "faktor av 5 är" << faktoriell << std :: endl ;
CFScript
faktoriell = 1 ; räkna = 10 ; gör { factorial *= count -- ; } while ( antal > 1 ); writeOutput ( faktoriell );
D
0
int räknare = 5 ; int factorial = 1 ; gör { faktoriell *= räknare --; // Multiplicera och minska sedan. } while ( räknare > ); writeln ( "faktoriell av 5 är", faktoriell ) ;
Fortran
Med äldre FORTRAN 77 finns det ingen DO-WHILE-konstruktion men samma effekt kan uppnås med GOTO:
0
HELTAL CNT , FAKTA CNT = 5 FAKTA = 1 1 FORTSÄTT FAKTA = FAKTA * CNT CNT = CNT - 1 IF ( CNT . GT . ) GÅ TILL 1 UTSKRIVNING * , FAKTA SLUT
Fortran 90 och senare har inte heller en do-while-konstruktion, men den har en while loop- konstruktion som använder nyckelorden "do while" och är alltså faktiskt densamma som for loop .
0
program FactorialProg heltal :: räknare = 5 heltal :: faktoriell = 1 faktoriell = faktoriell * räknare räknare = räknare - 1 gör while ( räknare > ) ! Sanningsvärdet testas före loopen faktoriell = faktoriell * räknare räknare = räknare - 1 slut gör utskrift * , faktoriellt slutprogram FactorialProg
Java
0
0
int räknare = 5 ; int factorial = 1 ; do { faktoriell *= räknare -- ; /* Multiplicera och minska sedan. */ } while ( räknare > ); System . ut . println ( "Faktorialen för 5 är " + faktoriell ); //==============================================// // Funktionen nedan gör samma sak som ovan. // //=============================================// int räknare = 5 ; int factorial = 1 ; while ( räknare > ){ faktoriell *= räknare -- ; /* Multiplicera och minska sedan. */ } System . ut . println ( "Faktorialen för 5 är " + faktoriell );
JavaScript
0
låt räknare = 5 ; // Deklarerar två variabler, räknare och faktoriell låt factorial = 1 ; do { faktoriell *= räknare -- ; //Vad kommer att loopas } while ( counter > ); // Konsolen för loopingvillkor . log ( faktoriell ); //Visar resultatet
Kotlin
0
var counter = 5 var factorial = 1 //Dessa kodrader är nästan samma som ovanstående JavaScript-koder, den enda skillnaden är nyckelordet som visar resultaten do { factorial *= counter -- } while ( counter > ) println ( "Faktor av 5 är $ factorial " )
Pascal
Pascal har ingen do/while; istället har den en upprepning/tills. Som nämnts i inledningen kan man betrakta en repetition/tills vara likvärdig med en "gör kod medan inte uttryck"-konstruktion.
0 faktoriell := 1 ; räknare := 5 ; repeat factorial := factorial * counter ; räknare := räknare - 1 ; // I Object Pascal kan man använda dec (räknare); tills räknare = ;
PHP
0
$counter = 5 ; $faktoriell = 1 ; gör { $faktoriell *= $counter -- ; } while ( $räknare > ); echo $faktoriellt ;
PL/I
PL /I DO-satsen subsumerar funktionerna för eftertestslingan ( gör tills ), förtestslingan ( do while ) och for-loopen . Alla funktioner kan inkluderas i ett enda uttalande. Exemplet visar bara "gör tills"-syntaxen.
förklara räknaren fixerad initial(5); förklara faktoriell fix initial(1); gör tills(räknare <= 0); faktoriell = faktoriell * räknare; räknare = räknare - 1; slutet; put(faktoriell);
Pytonorm
Python saknar en specifik do while-flödeskontrollkonstruktion. Motsvarigheten kan dock vara konstruerad ur en while-loop med en paus.
räknare = 5 faktoriell = 1 medan True : faktoriell *= räknare - = 1 om räknare == : bryt utskrift ( faktoriell )
0
Racket
I Racket, som i andra Scheme- implementeringar, är en "named-let" ett populärt sätt att implementera loopar:
0
#lang racket ( definiera räknare 5 ) ( definiera faktor 1 ) ( låt loop () ( set! factorial ( * faktoriell räknare )) ( ställ in! räknare ( sub1 räknare )) ( när ( > räknare ) ( loop ))) ( displayln faktoriellt )
Jämför detta med det första exemplet på while loop- exemplet för Racket. Var medveten om att en namngiven let också kan ta argument.
Racket och Scheme ger också en ordentlig do-loop.
0
( definiera ( faktoriellt n ) ( do (( räknare n ( - räknare 1 )) ( resultat 1 ( * resultaträknare ) )) (( = räknare ) resultat ) ; Stoppvillkor och returvärde. ; Do-loopens kropp är tom. ))
Rubin
räknare = 10 faktoriell = 2 börjar faktoriell *= räknare räknare -= 2 slut medan räknare > 1 sätter faktoriell
Småprat
0
| counter factorial | räknare := 5 . faktoriell := 1 . [ räknare > ] whileTrue: [ faktoriell := faktoriell * räknare . räknare := räknare - 1 ] . Transcript show: factorial printString
Snabb
Swift 2.x och senare:
0
var counter = 5 var factorial = 1 repeat { factorial *= counter counter -= 1 } medan räknare > print ( factorial )
Swift 1.x:
0
var räknare = 5 var factorial = 1 gör { factorial *= counter counter -= 1 } medan räknare > println ( faktoriell )
Visual Basic .NET
0
Dim räknare som heltal = 5 Dimfaktoriellt som heltal = 1 Gör faktoriell * = räknarräknare - = 1 loop medan räknare > Konsol . WriteLine ( faktoriell )