Gör while loop

Gör While loop flödesdiagram

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  ) 

Se även

externa länkar