Visual Basic .NET Language
looping

Voor de volgende

For ... Next lus wordt gebruikt om dezelfde actie een eindig aantal keren te herhalen. De instructies in de volgende lus worden 11 keer uitgevoerd. De eerste keer, i de waarde 0, de tweede keer wordt de waarde 1, de laatste keer dat de waarde 10 nodig te hebben.

For i As Integer = 0 To 10
    'Execute the action
    Console.Writeline(i.ToString)
Next

Elke integer-expressie kan worden gebruikt om de lus te parametreren. Het is toegestaan, maar niet vereist, dat de besturingsvariabele (in dit geval i ) ook wordt vermeld na de Next . Het is toegestaan om de besturingsvariabele vooraf te declareren in plaats van binnen de For instructie.

Dim StartIndex As Integer = 3
Dim EndIndex As Integer = 7
Dim i As Integer

For i = StartIndex To EndIndex - 1
    'Execute the action
    Console.Writeline(i.ToString)
Next i

Door de gehele getallen Start en End te definiëren, kunnen lussen worden gemaakt die direct naar andere objecten verwijzen, zoals:

For i = 0 to DataGridView1.Rows.Count - 1
    Console.Writeline(DataGridView1.Rows(i).Cells(0).Value.ToString)
Next

Dit zou dan elke rij in DataGridView1 doorlopen en de actie van het schrijven van de waarde van kolom 1 naar de console uitvoeren. (De -1 is omdat de eerste rij van de getelde rijen 1 zou zijn, niet 0)

Het is ook mogelijk om te definiëren hoe de besturingsvariabele moet worden verhoogd.

For i As Integer = 1 To 10 Step 2
    Console.Writeline(i.ToString)
Next 

Dit geeft uit:

1 3 5 7 9

Het is ook mogelijk om de besturingsvariabele te verlagen (aftellen).

For i As Integer = 10 To 1 Step -1
    Console.Writeline(i.ToString)
Next

Dit geeft uit:

10 9 8 7 6 5 4 3 2 1

Probeer niet de besturingsvariabele buiten de lus te gebruiken (lezen of bijwerken).

Voor elke ... Volgende lus voor het doorlopen van een verzameling items

U kunt een For Each...Next lus gebruiken om elk willekeurig IEnumerable type te doorlopen. Dit omvat arrays, lijsten en al het andere dat van het type IEnumerable kan zijn of een IEnumerable retourneert.

Een voorbeeld van het doorlopen van de eigenschap Rows van een DataTable ziet er zo uit:

For Each row As DataRow In DataTable1.Rows
    'Each time this loops, row will be the next item out of Rows
    'Here we print the first column's value from the row variable.
    Debug.Print(Row.Item(0))
Next 

Een belangrijk ding om op te merken is dat de verzameling niet moet worden gewijzigd terwijl in een For Each lus. Dit veroorzaakt een System.InvalidOperationException met het bericht:

Verzameling is gewijzigd; opsomming kan niet worden uitgevoerd.

Terwijl lus om te itereren terwijl enige voorwaarde waar is

A While lus begint met het evalueren van een voorwaarde. Als het waar is, wordt de body van de lus uitgevoerd. Nadat het lichaam van de lus is uitgevoerd, wordt de voorwaarde While opnieuw geëvalueerd om te bepalen of het lichaam opnieuw moet worden uitgevoerd.

Dim iteration As Integer = 1
While iteration <= 10
  Console.Writeline(iteration.ToString() & " ")

  iteration += 1
End While

Dit geeft uit:

1 2 3 4 5 6 7 8 9 10

Waarschuwing: een While lus kan leiden tot een oneindige lus . Bedenk wat er zou gebeuren als de regel code die iteration verhoogt, werd verwijderd. In een dergelijk geval zou de voorwaarde nooit Waar zijn en zou de lus voor onbepaalde tijd doorgaan.

Do ... Loop

Gebruik Do...Loop om een blok beweringen te herhalen While of Until een voorwaarde waar is, controleer de voorwaarde aan het begin of aan het einde van de lus.

Dim x As Integer = 0
Do
    Console.Write(x & " ")
    x += 1
Loop While x < 10

of

Dim x As Integer = 0
Do While x < 10
    Console.Write(x & " ")
    x += 1
Loop

0 1 2 3 4 5 6 7 8 9

Dim x As Integer = 0
Do
    Console.Write(x & " ")
    x += 1
Loop Until x = 10

of

Dim x As Integer = 0
Do Until x = 10
    Console.Write(x & " ")
    x += 1
Loop

0 1 2 3 4 5 6 7 8 9

Continue Do kan worden gebruikt om naar de volgende iteratie van de lus te gaan:

Dim x As Integer = 0
Do While x < 10
    x += 1
    If x Mod 2 = 0 Then
        Continue Do
    End If
    Console.Write(x & " ")
Loop

1 3 5 7 9

Je kunt de lus beëindigen met Exit Do - merk op dat in dit voorbeeld het ontbreken van een voorwaarde anders een oneindige lus zou veroorzaken:

Dim x As Integer = 0
Do
    Console.Write(x & " ")
    x += 1
    If x = 10 Then
        Exit Do
    End If
Loop

0 1 2 3 4 5 6 7 8 9

Kortsluiting

Elke lus kan op elk moment worden beëindigd of vroeg worden voortgezet met behulp van de instructies Exit of Continue .

afsluiten

Je kunt elke lus stoppen door vroegtijdig te stoppen. Om dit te doen, kunt u het sleutelwoord Exit samen met de naam van de lus.

Een lus vroegtijdig verlaten is een geweldige manier om de prestaties te verbeteren door alleen het benodigde aantal keren te herhalen om aan de behoeften van de toepassing te voldoen. Hieronder ziet u een voorbeeld waar de lus wordt afgesloten zodra het nummer 2 .

Dim Numbers As Integer() = {1,2,3,4,5}
Dim SoughtValue As Integer = 2
Dim SoughtIndex
For Each i In Numbers
    If i = 2 Then 
        SoughtIndex = i
        Exit For
    End If
Next
Debug.Print(SoughtIndex)

Voortzetting

Naast het vroegtijdig verlaten, kun je ook beslissen dat je gewoon door moet gaan naar de volgende lus iteratie. Dit kan eenvoudig worden gedaan met behulp van de instructie Continue . Net als Exit wordt dit gevolgd door de lusnaam.

Hier is een voorbeeld om te voorkomen dat even getallen aan de som worden toegevoegd.

Dim Numbers As Integer() = {1,2,3,4,5}
Dim SumOdd As Integer = 0
For Each i In Numbers
    If Numbers(i) \ 2 = 0 Then Continue For
    SumOdd += Numbers(i)
Next

Gebruiksadvies

Er zijn twee alternatieve technieken die kunnen worden gebruikt in plaats van Exit of Continue .

U kunt een nieuwe Booleaanse variabele declareren, deze op één waarde initialiseren en voorwaardelijk op de andere waarde in de lus instellen; u gebruikt dan een voorwaardelijke instructie (bijv. If ) op basis van die variabele om te voorkomen dat de instructies in de lus in volgende iteraties worden uitgevoerd.

Dim Found As Boolean = False
Dim FoundIndex As Integer
For i As Integer = 0 To N - 1
    If Not Found AndAlso A(i) = SoughtValue Then
        FoundIndex = i
        Found = True
    End If
Next

Een van de bezwaren tegen deze techniek is dat deze inefficiënt kan zijn. Als bijvoorbeeld in het bovenstaande voorbeeld N 1000000 is en het eerste element van de array A gelijk is aan SoughtValue , zal de lus nog 999999 keer itereren zonder iets nuttigs te doen. Deze techniek kan echter in sommige gevallen het voordeel hebben van meer duidelijkheid.

U kunt de GoTo opdracht gebruiken om uit de lus te springen. Merk op dat je GoTo niet kunt gebruiken om in een lus te springen.

    Dim FoundIndex As Integer
    For i As Integer = 0 To N - 1
        If A(i) = SoughtValue Then
            FoundIndex = i
            GoTo Found
        End If
    Next
    Debug.Print("Not found")
Found:
    Debug.Print(FoundIndex)

Deze techniek kan soms de meest nette manier zijn om uit de lus te springen en een of meer instructies te vermijden die net na het natuurlijke einde van de lus worden uitgevoerd.

Overweeg alle alternatieven en gebruik de optie die het beste bij uw eisen past, bijvoorbeeld efficiëntie, schrijfsnelheid van de code en leesbaarheid (dus onderhoudbaarheid).

Laat je niet afschrikken met het gebruik van GoTo wanneer het het beste alternatief is.

Geneste lus

A nested loop is a loop within a loop, an inner loop within the body of an outer one. How this works is that the first pass of the outer loop triggers the inner loop, which executes to completion. Then the second pass of the outer loop triggers the inner loop again. This repeats until the outer loop finishes. a break within either the inner or outer loop would interrupt this process.

De structuur van een geneste lus voor Volgende is:

For counter1=startNumber to endNumber (Step increment)

    For counter2=startNumber to endNumber (Step increment)

        One or more VB statements

    Next counter2

Next  counter1

Voorbeeld:

    For  firstCounter = 1 to 5

      Print “First Loop of ” + firstCounter

    For   secondCounter= 1 to 4

      Print “Second Loop of ” + secondCounter

    Next secondCounter

  Next firstCounter