Delen via

Voor... Volgende instructie (Visual Basic)

Herhaalt een groep instructies terwijl de lusvariabele zijn eindwaarde bereikt.

Syntaxis

For counter [ As datatype ] = start To end [ Step step ]
    [ statements ]
    [ Continue For ]
    [ statements ]
    [ Exit For ]
    [ statements ]
Next [ counter ]

Onderdelen

Onderdeel Beschrijving
counter Vereist in de For verklaring. Numerieke variabele. De besturingsvariabele voor de lus. Voor meer informatie, zie Counter Argument verderop in dit onderwerp.
datatype Facultatief. Gegevenstype van counter. Voor meer informatie, zie Counter Argument verderop in dit onderwerp.
start Verplicht. Numerieke expressie. De initiële waarde van counter.
end Verplicht. Numerieke expressie. De uiteindelijke waarde van counter.
step Facultatief. Numerieke expressie. Het bedrag waarmee counter elke keer door de lus wordt verhoogd.
statements Facultatief. Een of meer instructies tussen For en Next die het opgegeven aantal keren uitvoeren.
Continue For Facultatief. Draagt de controle over naar de volgende iteratie van de lus.
Exit For Facultatief. Hiermee wordt het beheer buiten de lus For overgedragen.
Next Verplicht. Hiermee wordt de definitie van de For lus beëindigd.

Opmerking

Het To trefwoord wordt in deze instructie gebruikt om het bereik voor de teller op te geven. U kunt dit trefwoord ook gebruiken in de Select...Case-instructie en in arraydeclaraties. Zie Dim-instructie voor meer informatie over matrixdeclaraties.

Eenvoudige voorbeelden

U gebruikt een For...Next -structuur als u een set instructies een bepaald aantal keren wilt herhalen.

In het volgende voorbeeld begint de index-variabele met een waarde van 1 en wordt verhoogd met elke iteratie van de lus, eindigend wanneer de waarde van index 5 bereikt.

For index As Integer = 1 To 5
    Debug.Write(index.ToString & " ")
Next
Debug.WriteLine("")
' Output: 1 2 3 4 5

In het volgende voorbeeld begint de number variabele bij 2 en wordt bij elke iteratie van de lus met 0,25 verminderd, eindigend na de waarde van number 0. Het Step argument van -.25 vermindert de waarde met 0,25 bij elke iteratie van de lus.

For number As Double = 2 To 0 Step -0.25
    Debug.Write(number.ToString & " ")
Next
Debug.WriteLine("")
' Output: 2 1.75 1.5 1.25 1 0.75 0.5 0.25 0

Aanbeveling

Een While...End While-verklaring of Do...Loop-verklaring werkt goed wanneer u niet van tevoren weet hoe vaak de instructies in de lus moeten worden uitgevoerd. Wanneer u echter verwacht dat de lus een bepaald aantal keren wordt uitgevoerd, is een For...Next lus een betere keuze. U bepaalt het aantal iteraties wanneer u de lus voor het eerst invoert.

Geneste lussen

U kunt For lussen nesten door de ene lus binnen een andere te plaatsen. In het volgende voorbeeld ziet u geneste For...Next structuren met verschillende stapwaarden. De buitenste lus maakt een tekenreeks voor elke iteratie van de lus. De binnenste lus verlaagt een lustellervariabele voor elke herhaling van de lus.

For indexA = 1 To 3
    ' Create a new StringBuilder, which is used
    ' to efficiently build strings.
    Dim sb As New System.Text.StringBuilder()

    ' Append to the StringBuilder every third number
    ' from 20 to 1 descending.
    For indexB = 20 To 1 Step -3
        sb.Append(indexB.ToString)
        sb.Append(" ")
    Next indexB

    ' Display the line.
    Debug.WriteLine(sb.ToString)
Next indexA
' Output:
'  20 17 14 11 8 5 2
'  20 17 14 11 8 5 2
'  20 17 14 11 8 5 2

Bij het nesten van lussen moet elke lus een unieke counter variabele hebben.

U kunt ook verschillende soorten besturingsstructuren binnen elkaar nesten. Zie voor meer informatie Geneste besturingsstructuren.

Verlaat For en Ga verder met For

De Exit For instructie beëindigt onmiddellijk de For... Next lus en draagt het besturingselement over naar de instructie die volgt op de Next instructie.

De Continue For instructie geeft de controle onmiddellijk over aan de volgende iteratie van de lus. Zie Continue-instructie voor meer informatie.

In het volgende voorbeeld ziet u het gebruik van de Continue For- en Exit For-instructies.

For index As Integer = 1 To 100000
    ' If index is between 5 and 7, continue
    ' with the next iteration.
    If index >= 5 AndAlso index <= 8 Then
        Continue For
    End If

    ' Display the index.
    Debug.Write(index.ToString & " ")

    ' If index is 10, exit the loop.
    If index = 10 Then
        Exit For
    End If
Next
Debug.WriteLine("")
' Output: 1 2 3 4 9 10

U kunt een willekeurig aantal Exit For statements in een For... Next lus. Wanneer gebruikt binnen geneste For... Next lus, Exit For verlaat de binnenste lus en draagt de controle over naar het volgende hogere niveau van nesten.

Exit For wordt vaak gebruikt nadat u een bepaalde voorwaarde hebt geëvalueerd (bijvoorbeeld in een If...Then...Else structuur). Mogelijk wilt u deze voorwaarden gebruiken Exit For :

  • Doorgaan met herhalen is onnodig of onmogelijk. Een onjuiste waarde of een beëindigingsaanvraag kan deze voorwaarde maken.

  • Een Try...Catch...Finally instructie handelt een uitzondering af. U kunt aan het einde van het Exit For blok gebruikenFinally.

  • U hebt een eindeloze lus, een lus die een groot of zelfs oneindig aantal keren kan worden uitgevoerd. Als u een dergelijke voorwaarde detecteert, kunt u de lus met Exit For doorbreken. Zie voor meer informatie Do...Loop-instructie.

Technische implementatie

Wanneer een For...Next-lus wordt gestart, evalueert Visual Basic start, end en step. Visual Basic evalueert deze waarden alleen op dit moment en wijst start vervolgens toe aan counter. Voordat het instructieblok wordt uitgevoerd, vergelijkt Visual Basic counter met end. Als counter al groter is dan de end-waarde (of kleiner als step negatief is), eindigt de For-lus en gaat de besturing naar de instructie die volgt op de Next-instructie. Anders wordt het declaratieblok uitgevoerd.

Telkens wanneer Visual Basic de Next-instructie tegenkomt, wordt counter met step verhoogd en keert terug naar de For-instructie. Opnieuw vergelijkt counter het met end, en opnieuw wordt het blok uitgevoerd of wordt de lus afgesloten, afhankelijk van het resultaat. Dit proces wordt voortgezet totdat counter voorbij end gaat of een Exit For-instructie wordt aangetroffen.

De lus stopt pas als counter voorbij end is gegaan. Als counter gelijk is aan end, herhaalt de lus zich. De vergelijking die bepaalt of het blok moet worden uitgevoerd, is counter<= end als step positief en counter>= end als step dit negatief is.

Als u de waarde van counter wijzigt terwijl u zich in een lus bevindt, kan het lastiger zijn om uw code te lezen en fouten op te sporen. Het wijzigen van de waarde van start, endof step heeft geen invloed op de iteratiewaarden die zijn bepaald toen de lus voor het eerst werd ingevoerd.

Als u lussen nestelt, geeft de compiler een foutmelding als deze de Next instructie van een buitenste nestniveau tegenkomt vóór de Next instructie van een binnenste niveau. De compiler kan deze overlappende fout echter alleen detecteren als u counter in elke Next verklaring opgeeft.

Stapargument

De waarde van step kan positief of negatief zijn. Deze parameter bepaalt lusverwerking volgens de volgende tabel:

Stapwaarde Lus wordt uitgevoerd als
Positief of nul counter <= end
Negatief counter >= end

De standaardwaarde van step is 1.

Tegenargument

In de volgende tabel wordt aangegeven of counter een nieuwe lokale variabele definieert die van toepassing is op de hele For…Next lus. Deze bepaling is afhankelijk van of datatype aanwezig is en of counter al is gedefinieerd.

Is datatype aanwezig? Is counter al gedefinieerd? Resultaat (of counter er een nieuwe lokale variabele wordt gedefinieerd die is gericht op de hele For...Next lus)
Nee. Ja Nee, omdat counter dit al is gedefinieerd. Als het bereik van counter niet lokaal is voor de procedure, ontstaat er een compile-tijd waarschuwing.
Nee. Nee. Ja. Het gegevenstype wordt afgeleid van de start, end en step expressies. Zie Option Infer Statement en Local Type Inference voor informatie over typedeductie.
Ja Ja Ja, maar alleen als de bestaande counter variabele buiten de procedure is gedefinieerd. Die variabele blijft gescheiden. Als het bereik van de bestaande counter variabele lokaal is voor de procedure, treedt er een compilatietijdfout op.
Ja Nee. Ja.

Het gegevenstype bepaalt counter het type iteratie, dat een van de volgende typen moet zijn:

  • Een Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single, of Double.

  • Een opsomming die u declareert met behulp van een Enum-instructie.

  • Een Object.

  • Een type T met de volgende operatoren, waarbij B een type is dat kan worden gebruikt in een Boolean expressie.

    Public Shared Operator >= (op1 As T, op2 As T) As B

    Public Shared Operator <= (op1 As T, op2 As T) As B

    Public Shared Operator - (op1 As T, op2 As T) As T

    Public Shared Operator + (op1 As T, op2 As T) As T

U kunt desgewenst de counter variabele in de Next instructie opgeven. Deze syntaxis verbetert de leesbaarheid van uw programma, met name als u geneste For lussen hebt. U moet de variabele opgeven die wordt weergegeven in de bijbehorende For instructie.

De start, enden step expressies kunnen evalueren op elk gegevenstype dat wordt uitgebreid tot het type counter. Als u een door de gebruiker gedefinieerd type gebruikt counter, moet u mogelijk de CType conversieoperator definiëren om de typen start, endof step naar het type counterte converteren.

Voorbeeld 1

In het volgende voorbeeld worden alle elementen uit een algemene lijst verwijderd. In plaats van een For Each... Volgende instructie toont het voorbeeld een For...Next -instructie die in aflopende volgorde wordt herhaald. In het voorbeeld wordt deze techniek gebruikt omdat de removeAt methode ervoor zorgt dat elementen na het verwijderde element een lagere indexwaarde hebben.

Dim lst As New List(Of Integer) From {10, 20, 30, 40}

For index As Integer = lst.Count - 1 To 0 Step -1
    lst.RemoveAt(index)
Next

Debug.WriteLine(lst.Count.ToString)
' Output: 0

Voorbeeld 2

In het volgende voorbeeld wordt een opsomming herhaald die wordt gedeclareerd met behulp van een Enum-instructie.

Public Enum Mammals
    Buffalo
    Gazelle
    Mongoose
    Rhinoceros
    Whale
End Enum

Public Sub ListSomeMammals()
    For mammal As Mammals = Mammals.Gazelle To Mammals.Rhinoceros
        Debug.Write(mammal.ToString & " ")
    Next
    Debug.WriteLine("")
    ' Output: Gazelle Mongoose Rhinoceros
End Sub

Voorbeeld 3

In het volgende voorbeeld gebruiken de instructieparameters een klasse met operator-overloads voor de operators +, -, >= en <=.

Private Class Distance
    Public Property Number() As Double

    Public Sub New(ByVal number As Double)
        Me.Number = number
    End Sub

    ' Define operator overloads to support For...Next statements.
    Public Shared Operator +(ByVal op1 As Distance, ByVal op2 As Distance) As Distance
        Return New Distance(op1.Number + op2.Number)
    End Operator

    Public Shared Operator -(ByVal op1 As Distance, ByVal op2 As Distance) As Distance
        Return New Distance(op1.Number - op2.Number)
    End Operator

    Public Shared Operator >=(ByVal op1 As Distance, ByVal op2 As Distance) As Boolean
        Return (op1.Number >= op2.Number)
    End Operator

    Public Shared Operator <=(ByVal op1 As Distance, ByVal op2 As Distance) As Boolean
        Return (op1.Number <= op2.Number)
    End Operator
End Class

Public Sub ListDistances()
    Dim distFrom As New Distance(10)
    Dim distTo As New Distance(25)
    Dim distStep As New Distance(4)

    For dist As Distance = distFrom To distTo Step distStep
        Debug.Write(dist.Number.ToString & " ")
    Next
    Debug.WriteLine("")

    ' Output: 10 14 18 22 
End Sub

Zie ook

  • Last updated on