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

Upprepar en grupp med instruktioner medan loopräknaren närmar sig sitt slutliga värde.

Syntax

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

Delar

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 för -.25 minskar värdet med 0,25 för varje iteration av slingan.

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 

Nästande loopar

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äknarvariabel 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 For och Fortsätt For

Instruktionen Exit For avslutar Foromedelbart ... Next -loopen och för över 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-sats.

Följande exempel illustrerar användningen av uttalandena Continue For och Exit 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 ögla. När det används inom 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-sats fångar upp ett undantag. Du kan använda Exit For i slutet av Finally blocket.

• Du har en oändlig loop, som är en loop som kan köras 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 start, Visual Basic end och 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 counter med end. Om counter är redan större än end (eller mindre om step är negativ), loopen For avslutas och kontrollen övergår till instruktionen som följer instruktionen Next. Annars körs instruktionsblocket.

Varje gång Visual Basic stöter på instruktionen Next ökas counter med step och återgår till instruktionen For. Återigen jämför den counter med end, och kör antingen blocket eller avslutar slingan, beroende på resultatet. Den här processen fortsätter tills counter passerar end eller en Exit For-instruktion påträffas.

Loopen stoppas inte förrän counter 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 när du är inne i en loop kan din kod bli 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 använder nästlade loopar signalerar kompilatorn ett fel ifall den stöter på 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:

Standardvärdet för step är 1.

Motargument

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.

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, Single eller Double.

• En uppräkning som du deklarerar med hjälp av en Enum-sats.

• 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. Istället för en För Varje... Nästa-sats visar exemplet en For...Next-sats 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 en Enum-sats.

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

Se även

• List<T>
• Loopstrukturer
• Medan... End While-instruktion
• Göra... Loop-instruktion
• Kapslade kontrollstrukturer
• Exit-instruktion
• samlingar