För... Nästa instruktion (Visual Basic)

Artikel
03/05/2024

Upprepar en grupp med instruktioner ett angivet antal gånger.

Syntax

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

Delar

Delvis	beskrivning
`counter`	Krävs i -instruktionen `For` . Numerisk variabel. Kontrollvariabeln för loopen. Mer information finns i Räknarargument senare i det här avsnittet.
`datatype`	Valfritt. Datatyp för `counter`. Mer information finns i Räknarargument senare i det här avsnittet.
`start`	Obligatoriska. Numeriskt uttryck. Det ursprungliga värdet för `counter`.
`end`	Obligatoriska. Numeriskt uttryck. Det slutliga värdet för `counter`.
`step`	Valfritt. Numeriskt uttryck. Mängden som `counter` ökas varje gång genom loopen.
`statements`	Valfritt. En eller flera instruktioner mellan `For` och `Next` som kör det angivna antalet gånger.
`Continue For`	Valfritt. Överför kontrollen till nästa loop-iteration.
`Exit For`	Valfritt. Överför kontrollen utanför loopen `For` .
`Next`	Obligatoriska. Avslutar definitionen av loopen `For` .

Kommentar

Nyckelordet To används i den här instruktionen för att ange intervallet för räknaren. Du kan också använda det här nyckelordet i Välj ... Case Statement och i matrisdeklarationer. Mer information om matrisdeklarationer finns i Dim-instruktion.

Enkla exempel

Du använder en For...Next struktur när du vill upprepa en uppsättning instruktioner ett visst antal gånger.

I följande exempel börjar variabeln index med värdet 1 och ökas med varje iteration av loopen och slutar efter att värdet index för når 5.

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

I följande exempel börjar variabeln number vid 2 och minskas med 0,25 vid varje iteration av loopen och slutar efter värdet för number når 0. Argumentet Step-.25 för minskar värdet med 0,25 för varje iteration av loopen.

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

Dricks

Ett tag... End While-instruktion eller Gör... Loop-instruktionen fungerar bra när du inte i förväg vet hur många gånger instruktionen ska köras i -loopen. Men när du förväntar dig att köra loopen ett visst antal gånger är en For...Next -loop ett bättre val. Du avgör antalet iterationer när du först anger loopen.

Kapslingor

Du kan kapsla For loopar genom att placera en loop i en annan. I följande exempel visas kapslade For...Next strukturer som har olika stegvärden. Den yttre loopen skapar en sträng för varje iteration av loopen. Den inre loopen minskar en loopräknare för varje iteration av loopen.

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

När du kapslar loopar måste varje loop ha en unik counter variabel.

Du kan också kapsla olika typer av kontrollstrukturer inom varandra. Mer information finns i Kapslade kontrollstrukturer.

Avsluta för och fortsätt för

Instruktionen Exit For avslutar Foromedelbart ...Next loop och överför kontrollen till -instruktionen som följer -instruktionen Next .

Instruktionen Continue For överför kontrollen omedelbart till nästa iteration av loopen. Mer information finns i Fortsätt-instruktion.

Följande exempel illustrerar användningen av - och Exit For -uttryckenContinue For.

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

Du kan placera valfritt antal Exit For instruktioner i en For...Next Loop. När den används i kapslade For...Next loopar, Exit For avslutar den innersta loopen och överför kontrollen till nästa högre kapslingsnivå.

Exit For används ofta när du har utvärderat något villkor (till exempel i en If...Then...Else struktur). Du kanske vill använda Exit For för följande villkor:

Att fortsätta iterera är onödigt eller omöjligt. Ett felaktigt värde eller en avslutningsbegäran kan skapa det här villkoret.
A Try...Catch...Finally -instruktionen fångar upp ett undantag. Du kan använda Exit For i slutet av Finally blocket.
Du har en oändlig loop, vilket är en loop som kan köra ett stort eller till och med oändligt antal gånger. Om du identifierar ett sådant villkor kan du använda Exit For för att undkomma loopen. Mer information finns i Gör... Loop-instruktion.

Teknisk implementering

När en For...Next -loop startar utvärderar startVisual Basic , endoch step. Visual Basic utvärderar endast dessa värden just nu och tilldelar start sedan till counter. Innan instruktionsblocket körs jämför Visual Basic med counterend. Om counter är redan större än end värdet (eller mindre om step det är negativt), avslutas loopen For och kontrollen skickas till -instruktionen som följer -instruktionen Next . Annars körs instruktionsblocket.

Varje gång Visual Basic stöter på -instruktionen Next ökar counterstep den med och återgår till -instruktionen For . Återigen jämförs counterendden med , och återigen kör den antingen blocket eller avslutar loopen, beroende på resultatet. Den här processen fortsätter tills en instruktion har godkänts counterend eller en Exit For instruktion har påträffats.

Loopen stoppas inte förrän counter den har passerat end. Om counter är lika med endfortsätter loopen. Jämförelsen som avgör om blocket ska köras är counter<= end om step är positivt och counter>= end om step är negativt.

Om du ändrar värdet counter för när du är inne i en loop kan koden vara svårare att läsa och felsöka. Att ändra värdet startför , endeller step påverkar inte de iterationsvärden som fastställdes när loopen först angavs.

Om du kapslar loopar signalerar kompilatorn ett fel om det påträffar instruktionen Next för en yttre kapslingsnivå före instruktionen Next för en inre nivå. Kompilatorn kan dock bara identifiera det överlappande felet om du anger counter i varje Next instruktion.

Stegargument

Värdet step för kan vara antingen positivt eller negativt. Den här parametern bestämmer loopbearbetning enligt följande tabell:

Stegvärde	Loopen körs om
Positiv eller noll	`counter`<= `end`
Negativa	`counter`>= `end`

Standardvärdet step för är 1.

Räknarargument

Följande tabell anger om counter definierar en ny lokal variabel som är begränsad till hela For…Next loopen. Den här bedömningen beror på om datatype finns och om counter den redan har definierats.

Är `datatype` det här?	Har `counter` du redan definierats?	Resultat (om `counter` definierar en ny lokal variabel som är begränsad till hela `For...Next` loopen)
Nej	Ja	Nej, eftersom `counter` har redan definierats. Om omfånget `counter` för inte är lokalt för proceduren inträffar en kompileringstidsvarning.
Nej	Nej	Ja. Datatypen härleds från uttrycken `start`, `end`och `step` . Information om typinferens finns i Inferens för alternativinferens och lokal typinferens.
Ja	Ja	Ja, men bara om den befintliga `counter` variabeln definieras utanför proceduren. Variabeln förblir separat. Om omfattningen för den befintliga `counter` variabeln är lokal för proceduren uppstår ett kompileringsfel.
Ja	Nej	Ja.

Datatypen counter avgör typen av iteration, som måste vara en av följande typer:

A Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Singleeller Double.
En uppräkning som du deklarerar med hjälp av en uppräkningsinstruktion.
En Object.
En typ T som har följande operatorer, där B är en typ som kan användas i ett Boolean uttryck.

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

Du kan också ange variabeln counter i -instruktionen Next . Den här syntaxen förbättrar programmets läsbarhet, särskilt om du har kapslade For loopar. Du måste ange variabeln som visas i motsvarande For instruktion.

Uttrycken start, endoch step kan utvärderas till alla datatyper som vidgas till typen counter. Om du använder en användardefinierad typ för counterkan du behöva definiera konverteringsoperatorn CType för att konvertera typerna av start, endeller step till typen .counter

Exempel 1

I följande exempel tar du bort alla element från en allmän lista. I stället för en för varje... Nästa instruktion visar exemplet en For...Next -instruktion som itererar i fallande ordning. Exemplet använder den här tekniken eftersom removeAt metoden gör att elementen efter det borttagna elementet har ett lägre indexvärde.

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

Exempel 2

I följande exempel itereras genom en uppräkning som deklareras med hjälp av en uppräkningsinstruktion.

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

Exempel 3

I följande exempel använder instruktionsparametrarna en klass som har operatoröverbelastningar för operatorerna +, -, >=och <= .

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

Dela via