Sløjfer i programmering tillader et sæt instruktioner at køre flere gange baseret på en betingelse. I Java er der tre typer af løkker, som er forklaret nedenfor:

1. for sløjfe

For-løkken bruges, når vi kender antallet af iterationer (vi ved, hvor mange gange vi vil gentage en opgave). For-sætningen inkluderer initialiseringsbetingelsen og stigning/reduktion på én linje. 

Eksempel: Nedenstående Java-program viser en for-løkke, der udskriver tal fra 0 til 10 på en enkelt linje.

   // Java program to demonstrates the working of for loop   import     java.io.*  ;   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      for     (  int     i     =     0  ;     i      <=     10  ;     i  ++  )     {      System  .  out  .  print  (  i     +     ' '  );      }      }   }   

0 1 2 3 4 5 6 7 8 9 10  

Syntaks:

for (initialisering; betingelse; stigning/nedsættelse) {

// kode, der skal udføres

}

Billedet nedenfor viser flowdiagrammet for en for-løkke:

• Initialiseringstilstand : Her initialiserer vi variablen i brug. Det markerer starten på en for-løkke. En allerede erklæret variabel kan bruges, eller en variabel kan kun erklæres lokal til sløjfe.
• Testtilstand: Den bruges til at teste udgangstilstanden for en sløjfe. Den skal returnere en boolesk værdi. Det er også en Entry Control Loop, da betingelsen kontrolleres før udførelse af loop-sætningerne.
• Udførelse af erklæring : Når betingelsen er evalueret til at være sand, udføres sætningerne i loop-kroppen.
• Øge/reducere : Den bruges til at opdatere variablen til næste iteration.
• Sløjfeterminering :Når tilstanden bliver falsk, afsluttes sløjfen og markerer afslutningen på dens livscyklus.

Note : Der er en anden form for for-løkken kendt som Forbedret til loop eller (for hver sløjfe).

Forbedret til loop (for hver)

Denne loop bruges til at iterere over arrays eller samlinger.

Eksempel : Nedenstående Java-program demonstrerer en Enhanced for loop (for hver loop) til at iterere gennem en matrix og udskrive navne.

   // Java program to demonstrate    // the working of for each loop   import     java.io.*  ;   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      String  []     names     =     {     'Sweta'       'Gudly'       'Amiya'     };      for     (  String     name     :     names  )     {      System  .  out  .  println  (  'Name: '     +     name  );      }      }   }   

Name: Sweta Name: Gudly Name: Amiya  

Syntaks:

for (dataType variabel: arrayOrCollection) {

// kode, der skal udføres

}

2. mens Loop

En while-løkke bruges, når vi vil kontrollere tilstanden, før vi udfører loop-kroppen.

Eksempel: Nedenstående Java-program viser en while-løkke, der udskriver tal fra 0 til 10 på en enkelt linje.

   // Java program to demonstrates    // the working of while loop   import     java.io.*  ;   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      int     i     =     0  ;      while     (  i      <=     10  )     {      System  .  out  .  print  (  i     +     ' '  );      i  ++  ;      }      }   }   

0 1 2 3 4 5 6 7 8 9 10  

Syntaks:

while (tilstand) {

// kode, der skal udføres

}

Billedet nedenfor viser flowdiagrammet for en while-løkke:

• Mens loop starter med kontrol af boolsk tilstand. Hvis den evalueres til sand, udføres loop body-sætningerne, ellers udføres den første sætning efter løkken. Af denne grund kaldes det også Entry Control loop
• Når betingelsen er evalueret til at være sand, udføres sætningerne i loop-kroppen. Normalt indeholder sætningerne en opdateringsværdi for den variabel, der behandles til næste iteration.
• Når tilstanden bliver falsk, afsluttes løkken, hvilket markerer afslutningen på dens livscyklus.

3. gør-mens-løkke

Do-while-løkken sikrer, at kodeblokken eksekveres mindst én gang før du tjekker tilstanden.

Eksempel : Nedenstående Java-program demonstrerer en do-while loop, der udskriver tal fra 0 til 10 på en enkelt linje.

   // Java program to demonstrates    // the working of do-while loop   import     java.io.*  ;   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      int     i     =     0  ;      do     {      System  .  out  .  print  (  i     +     ' '  );      i  ++  ;      }     while     (  i      <=     10  );      }   }   

0 1 2 3 4 5 6 7 8 9 10  

Syntaks:

gør {

// kode, der skal udføres

} mens (tilstand);

Billedet nedenfor viser flowdiagrammet for en do-while loop:

• do while loop starter med udførelsen af ​​sætningen. Der er ingen kontrol af nogen tilstand for første gang.
• Efter udførelse af sætningerne og opdatering af variabelværdien kontrolleres betingelsen for sand eller falsk værdi. Hvis det vurderes til sand, starter næste iteration af loop.
• Når tilstanden bliver falsk, afsluttes løkken, hvilket markerer afslutningen på dens livscyklus.
• Det er vigtigt at bemærke, at do-while-løkken vil udføre sine sætninger mindst én gang, før nogen betingelse kontrolleres og derfor er et eksempel på exit-kontrolløkke.

Almindelige sløjfefejl og hvordan man undgår dem

Hvis sløjfer ikke bruges korrekt, kan de introducere faldgruber og fejl, der påvirker kodeydelsens læsbarhed og funktionalitet. Nedenfor er nogle almindelige faldgruber ved loops:

1. Uendelige sløjfer

Dette er en af ​​de mest almindelige fejl, når man implementerer enhver form for looping, er, at den måske aldrig afsluttes, da loopen kører i uendelig tid. Dette sker, når tilstanden fejler af en eller anden grund.

Typer af uendelige sløjfer:

• uendelig for Loop
• uendelig mens Loop

Eksempel: Her demonstrerer begge eksempler de uendelige sløjfer.

   // Java program to demonstrate    // the infinite for loop   import     java.io.*  ;   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      for     (  int     i     =     0  ;     i      <     5  ;     i  --  )     {      System  .  out  .  println  (      'This loop will run forever'  );      }      }   }   

   // Java Program to demonstrate    // the infinite while loop   import     java.io.*  ;   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      while  (  true  )      {      System  .  out  .  println  (      'Basic example of infinte loop'  );      }      }   }   

Produktion: Når du kører begge ovenstående koder vil du få TLE (Time Limit Exceeded) fejl.

2. Off-by-One-fejl

Off-by-One-fejl opstår, når løkken kører én gang mere eller én gang færre, end man ønskede. Det sker som udgangspunkt, når sløjfetilstanden ikke er indstillet korrekt.

Eksempel : Nedenstående Java-program viser en Off-by-One-fejl, hvor løkken kører 6 gange, og vi forventede, at den ville køre 5 gange.

   // Java Program to demonstrates Off-by-One Errors   import     java.io.*  ;   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      for     (  int     i     =     0  ;     i      <=     5  ;     i  ++  )     {      System  .  out  .  print  (  i     +     ' '  );      }      }   }   

3. Ændring af løkkevariabler inde i løkken

Når vi ændrer sløjfebetingelsen (som i) inde i løkken, kan det få løkken til at springe visse iterationer over eller opføre sig på måder, som vi ikke havde forventet. Dette kan føre til fejl eller uventet adfærd.

Eksempel : Nedenstående Java-program demonstrerer ændring af løkkevariablen inde i løkken, hvilket får løkken til at springe visse iterationer over og opføre sig uventet.

   // Java program demonstrates    // modification in i variable   import     java.io.*  ;   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      for     (  int     i     =     0  ;     i      <     5  ;     i  ++  )     {      if     (  i     ==     2  )     {          // Modifies the loop variable and skips      // the next iteration      i  ++  ;      }      System  .  out  .  println  (  i  );      }      }   }   

4. Tøm løkkelegemet

En tom løkketekst opstår, når en løkke skrives til iteration, men ikke udfører nogen operationer inde i løkken. Det kan være forvirrende at køre en løkke uden brugbare handlinger.

Eksempel: Nedenstående Java-program viser Empty loop body.

   // Java program to demonstrates Empty loop body   import     java.io.*  ;   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      for     (  int     i     =     0  ;     i      <     10  ;     i  ++  )     {          // Empty body no operations      }      }   }   

Der vil ikke blive genereret noget output for dette, fordi løkkens krop er tom.

Oversigtstabel

Relaterede indlæg:

• for sløjfe
• mens loop
• gør-mens-løkke