Gør mens loop - Do while loop

Gør mens loop-diagram

I de fleste computerprogrammeringssprog er en do while-sløjfe en kontrolflowerklæring , der udfører en blok kode mindst en gang og derefter enten gentagne gange udfører blokken eller stopper med at udføre den afhængigt af en given boolsk tilstand i slutningen af blokken .

Den gøre, mens konstruktionen består af en proces symbol og en betingelse. Først udføres koden inden for blokken, og derefter evalueres tilstanden. Hvis betingelsen er sand, udføres koden inden for blokken igen. Dette gentages, indtil betingelsen bliver falsk . Fordi når sløjfer kontrollerer tilstanden, efter at blokken er udført, er kontrolstrukturen ofte også kendt som en posttest-løkke . Kontrast med while-sløjfen , som tester tilstanden, før koden inden for blokken udføres, gør-mens-sløjfen er en exit-tilstandsløjfe. Dette betyder, at koden altid skal udføres først, og derefter evalueres udtrykket eller testtilstanden. Hvis det er sandt, udfører koden sløjfekroppen igen. Denne proces gentages, så længe udtrykket evalueres til sandt. Hvis udtrykket er forkert, afsluttes sløjfen, og kontrol overføres til udsagnet efter "do-while" -sløjfen. Med andre ord, hvorimod en while-løkke sætter sandheden af en erklæring som en betingelse, der er præcedens for kodens udførelse, giver en do-while-sløjfe handlingens løbende udførelse underlagt afskedigelse af betingelsens falskhed, hvilken falskhed ( dvs. sandheden om tilstandens negation) er angivet som en betingelse efterfølgende .

Det er muligt, og i nogle tilfælde ønskeligt, at tilstanden altid evalueres til sand, hvilket skaber en uendelig løkke . Når en sådan sløjfe oprettes med vilje, er der normalt en anden kontrolstruktur (som f.eks. En break-sætning ), der muliggør afslutning af sløjfen.

Nogle sprog bruger muligvis en anden navngivningskonvention for denne type loop. For eksempel har Pascal- og Lua- sprogene en " gentag indtil " -sløjfe, som fortsætter med at køre, indtil kontroludtrykket er sandt (og derefter afsluttes) - hvorimod en "mens" -strop løber, mens kontroludtrykket er sandt (og afsluttes, når udtryk bliver falsk).

Ækvivalente konstruktioner

do {
    do_work();  
} while (condition);

svarer til

do_work();

while (condition) {
    do_work();
}

På denne måde gemmer do ... while-sløjfen den indledende "loop-priming" med do_work();på linjen før whileloop.

Så længe fortsættelseserklæringen ikke bruges, svarer ovenstående teknisk til følgende (selvom disse eksempler ikke er typiske eller moderne anvendt i almindelige computere):

while (true) {
   do_work();
   if (!condition) break;
}

eller

LOOPSTART:
    do_work();
    if (condition) goto LOOPSTART;

Demonstrere gør mens sløjfer

Disse eksempelprogrammer beregner faktoren på 5 ved hjælp af deres respektive sprogs syntaks for en do-while-loop.

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;

GRUNDLÆGGENDE

Tidlige GRUNDLÆGGENDE (såsom GW-GRUNDLÆGGENDE ) brugte syntaksen WHILE / WEND. Moderne BASICs som PowerBASIC giver både WHILE / WEND og DO / LOOP strukturer med syntaks som DO WHILE / LOOP, DO UNTIL / LOOP, DO / LOOP WHILE, DO / LOOP UNTIL og DO / LOOP (uden ydre test, men med et betinget EXIT LOOP et eller andet sted inde i loop). Typisk BASIC kildekode:

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) udsagn bruges også ofte i C-makroer som en måde at pakke flere udsagn ind i en almindelig (i modsætning til sammensat) udsagn. Det skaber et semikolon, der er nødvendigt efter makroen, hvilket giver et mere funktionslignende udseende til enkle parsere og programmører samt undgår scoping-problemet med if. Det anbefales i CERT C Coding Standard regel 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

Med den gamle FORTRAN 77 er der ingen DO-WHILE-konstruktion, men den samme effekt kan opnås med 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 og nyere har heller ikke en do-while-konstruktion, men den har en while-loopkonstruktion, der bruger nøgleordene "do while" og er således faktisk den samme som for-loop .

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 har ikke et do / while; i stedet har den en gentagelse / indtil. Som nævnt i indledningen kan man betragte en gentagelse / indtil som svarende til en 'do code while not expression'-konstruktion.

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

Den PL / I DO redegørelse indordner funktionerne i post-test løkke ( gøre indtil ), forprøven løkke ( gøre, mens ), og den for-løkken . Alle funktioner kan inkluderes i en enkelt erklæring. Eksemplet viser kun syntaks "gør indtil".

declare counter   fixed initial(5);
declare factorial fixed initial(1);

do until(counter <= 0);
    factorial = factorial * counter;
    counter = counter - 1;
end;

put(factorial);

Python

Python mangler en bestemt do while flow-kontrolkonstruktion. Imidlertid kan ækvivalenten konstrueres ud af en while-loop med en pause.

counter = 5
factorial = 1

while True:
    factorial *= counter
    counter -= 1
    
    if counter == 0:
        break
    
print(factorial)

Ketsjer

I Racket, som i andre Scheme- implementeringer, er en "named-let" en populær måde at implementere sløjfer på:

#lang racket
(define counter 5)
(define factorial 1)
(let loop ()
    (set! factorial (* factorial counter))
    (set! counter (sub1 counter))
    (when (> counter 0) (loop)))
(displayln factorial)

Sammenlign dette med det første eksempel på while loop- eksemplet til Racket. Vær opmærksom på, at en navngivet lad også kan tage argumenter.

Racket og Scheme giver også en ordentlig do loop.

(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

Småsnak

| counter factorial |
counter := 5.
factorial := 1.

[counter > 0] whileTrue: 
    [factorial := factorial * counter.
    counter := counter - 1].

Transcript show: factorial printString

Hurtig

Swift 2.x og senere:

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)

Se også

Referencer

eksterne links

gør {...} mens (0) i C-makroer

Languages

In other projects