Lussen begrijpen en gebruiken in Delphi-programmering

De lus is een gemeenschappelijk element in alle programmeertalen. Delphi heeft er drie controlestructuren die herhaaldelijk codeblokken uitvoeren: voor, herhaal... tot en terwijl... Doen.

Stel dat we een operatie een vast aantal keren moeten herhalen.

// toon 1,2,3,4,5 berichtvensters
var j: geheel getal;
beginnen
voor j: = 1 naar 5 Doen
beginnen
ShowMessage ('Box:' + IntToStr (j));
einde;
einde;

De waarde van een controlevariabele (j), die eigenlijk slechts een teller is, bepaalt hoe vaak een for-instructie wordt uitgevoerd. Het trefwoord voor het opzetten van een teller. In het voorgaande voorbeeld is de startwaarde voor de teller op 1 gezet. De eindwaarde is ingesteld op 5.
Wanneer de for-instructie begint te lopen, wordt de tellervariabele ingesteld op de beginwaarde. Delphi dan controleert of de waarde voor de teller kleiner is dan de eindwaarde. Als de waarde groter is, wordt er niets gedaan (programma-uitvoering springt naar de coderegel onmiddellijk volgend op het for-lus-codeblok). Als de beginwaarde kleiner is dan de eindwaarde, wordt de hoofdtekst van de lus uitgevoerd (hier wordt het berichtvenster weergegeven). Ten slotte voegt Delphi 1 toe aan de teller en start het proces opnieuw.

Soms is het nodig om achteruit te tellen. De beneden trefwoord specificeert dat de waarde van een teller elke keer dat de lus wordt uitgevoerd met één moet worden verlaagd (het is niet mogelijk om een ​​andere toename / afname op te geven). Een voorbeeld van een for-lus die achteruit telt.

var j: geheel getal;
beginnen
voor j: = 5 beneden 1 Doen
beginnen
ShowMessage ('T minus' + IntToStr (j) + 'seconden');
einde;
ShowMessage ('Voor sequentie uitgevoerd!');
einde;

Opmerking: het is belangrijk dat u nooit de waarde van de controlevariabele in het midden van de lus verandert. Als u dit wel doet, ontstaan ​​er fouten.

Het schrijven van een for-lus binnen een andere for-lus (nesting-lussen) is erg handig wanneer u gegevens in een tabel of een raster wilt vullen / weergeven.

var k, j: geheel getal;
beginnen
// deze dubbele lus wordt 4x4 = 16 keer uitgevoerd
voor k: = 1 naar 4 Doen
voor j: = 4 beneden 1 Doen
ShowMessage ('Box:' + IntToStr (k) + ',' + IntToStr (j));
einde;

De regel voor nesten voor volgende lussen is eenvoudig: de binnenste lus (j-teller) moet worden voltooid voordat de volgende instructie voor de buitenste lus wordt aangetroffen (k-teller). We kunnen drievoudige of viervoudig geneste lussen hebben, of zelfs meer.

Opmerking: Over het algemeen zijn de begin- en eindzoekwoorden niet strikt vereist, zoals u kunt zien. Als begin en einde niet worden gebruikt, wordt de instructie onmiddellijk na de instructie for beschouwd als de hoofdtekst van de lus.

Als u Delphi 2005 of een nieuwere versie hebt, kunt u de "nieuwe" iteratie voor element-in-collectie gebruiken over containers. Het volgende voorbeeld laat zien iteratie over string-expressies: controleer voor elk teken in tekenreeks of het teken 'a' of 'e' of 'i' is.

const
s = 'Over Delphi Programming';
var
c: char;
beginnen
voor c in s Doen
beginnen
als c in ['a', 'e', ​​'i'] vervolgens
beginnen
// doe iets
einde;
einde;
einde;

Soms weten we niet precies hoe vaak een lus moet fietsen. Wat als we een operatie willen herhalen totdat we een bepaald doel hebben bereikt?

Het belangrijkste verschil tussen de while-do-lus en de herhaling-tot-lus is dat de code van de herhaal de verklaring wordt altijd minstens één keer uitgevoerd.

Het algemene patroon wanneer we een herhaling (en terwijl) type lus schrijven in Delphi is als volgt:

herhaling
beginnen
verklaringen;
einde;
tot voorwaarde = waar

terwijl voorwaarde = waar Doen
beginnen
verklaringen;
einde;

Hier is de code om 5 opeenvolgende berichtvensters weer te geven met herhaling tot:

var
j: geheel getal;
beginnen
j: = 0;
herhaling
beginnen
j: = j + 1;
ShowMessage ('Box:' + IntToStr (j));
einde;
tot j> 5;
einde;

Zoals u kunt zien, evalueert de herhaalinstructie een voorwaarde aan het einde van de lus (daarom wordt de herhaallus zeker één keer uitgevoerd).

De while-instructie evalueert daarentegen een voorwaarde aan het begin van de lus. Aangezien de test bovenaan wordt uitgevoerd, moeten we er meestal voor zorgen dat de conditie logisch is voordat de lus wordt verwerkt, als dit niet waar is, compiler kan besluiten om de lus uit de code te verwijderen.

var j: geheel getal;
beginnen
j: = 0;
terwijl j <5 Doen
beginnen
j: = j + 1;
ShowMessage ('Box:' + IntToStr (j));
einde;
einde;

De Break and Continue-procedures kunnen worden gebruikt om de stroom van herhaalde uitspraken te beheersen: The Break procedure zorgt ervoor dat de controlestroom een ​​for, while of statement herhaalt en doorgaat met de volgende uitspraak de lus volgen uitspraak. Doorgaan zorgt ervoor dat de controlestroom doorgaat naar de volgende herhaling van de herhalingsbewerking.