Voor... Volgende instructie (Visual Basic)

Artikel
03/05/2024

Herhaalt een groep instructies een opgegeven aantal keren.

Syntaxis

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

generator

Onderdeel	Beschrijving
`counter`	Vereist in de `For` instructie. Numerieke variabele. De besturingsvariabele voor de lus. Zie Het tellerargument verderop in dit onderwerp voor meer informatie.
`datatype`	Optioneel. Gegevenstype van `counter`. Zie Het tellerargument verderop in dit onderwerp voor meer informatie.
`start`	Vereist. Numerieke expressie. De initiële waarde van `counter`.
`end`	Vereist. Numerieke expressie. De uiteindelijke waarde van `counter`.
`step`	Optioneel. Numerieke expressie. Het bedrag waarmee `counter` elke keer door de lus wordt verhoogd.
`statements`	Optioneel. Een of meer instructies tussen `For` en `Next` die het opgegeven aantal keren uitvoeren.
`Continue For`	Optioneel. Hiermee wordt het besturingselement overgedragen naar de volgende lusiteratie.
`Exit For`	Optioneel. Hiermee wordt het beheer buiten de lus `For` overgedragen.
`Next`	Vereist. Hiermee wordt de definitie van de `For` lus beëindigd.

Notitie

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 knop Selecteren... Case-instructie en in matrixdeclaraties. 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 na de waarde van index 5.

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

Tip

Een tijdje... Instructie Tijdens beëindigen of doen... Lusinstructie 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 lussen nesten door de ene lus in een andere te plaatsen For . 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 maakt een lustellervariabele af 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 Geneste besturingsstructuren voor meer informatie.

Afsluiten voor en doorgaan voor

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

Met Continue For de instructie wordt het besturingselement onmiddellijk overgedragen naar 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 instructies in een For...Next Lus. Wanneer gebruikt binnen geneste For...Next lussen, Exit For sluit de binnenste lus af 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 onderschept een uitzondering. U kunt aan het einde van het Finally blok gebruikenExit For.
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 Exit For lus ontsnappen. Zie Do voor meer informatie ... Lusinstructie.

Technische implementatie

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

Telkens wanneer Visual Basic de instructie tegenkomt, wordt deze Next verhoogd counterstep en geretourneerd 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 er een geslaagde end of instructie Exit For is aangetroffen.

De lus stopt pas als counter de lus is verstreken end. Als counter dit gelijk is aan end, gaat de lus door. 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 een lus wijzigt, 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 lus nestt, krijgt 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 in elke Next instructie opgeeftcounter.

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 is step 1.

Tellerargument

In de volgende tabel wordt aangegeven of counter er een nieuwe lokale variabele wordt gedefinieerd die is afgestemd 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)
Nr.	Ja	Nee, omdat `counter` dit al is gedefinieerd. Als het bereik van `counter` de procedure niet lokaal is, treedt er een waarschuwing over de compilatietijd op.
Nee	Nr.	Ja. Het gegevenstype wordt afgeleid van de `start`expressies en `endstep` de 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	Nr.	Ja.

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

A Byte, , SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, , , Singleof 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 operatorbelastingen voor de +operators , ->=en <= operators.

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

Delen via