For...Next-Anweisung (Visual Basic)

Wiederholt eine Gruppe von Anweisungen, während sich der Counter der Schleife seinem Endwert nähert.

Syntax

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

Bestandteile

Einfache Beispiele

Sie verwenden eine For...Next -Struktur, wenn Sie eine Reihe von Anweisungen eine festgelegte Anzahl von Malen wiederholen möchten.

Im folgenden Beispiel beginnt die Variable index mit einem Wert von 1 und wird mit jeder Iteration der Schleife erhöht, bis index den Wert 5 erreicht.

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

Im folgenden Beispiel beginnt die Variable number bei 2 und wird bei jeder Iteration der Schleife um 0,25 reduziert, bis der Wert von number 0 erreicht. Das Step-Argument von -.25 reduziert den Wert bei jeder Iteration der Schleife um 0,25.

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 

Schachtelungsschleifen

Sie können For-Schleifen schachteln, indem Sie eine Schleife in einer anderen platzieren. Das folgende Beispiel veranschaulicht geschachtelte For...Next Strukturen, die unterschiedliche Schrittwerte aufweisen. Die äußere Schleife erstellt eine Zeichenfolge für jede Iteration der Schleife. Die innere Schleife verringert eine Schleifenzählervariable für jede Iteration der Schleife.

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

Beim Verschachteln von Schleifen muss jede Schleife eine eindeutige counter Variable haben.

Sie können auch unterschiedliche Arten von Steuerelementstrukturen miteinander verschachteln. Weitere Informationen finden Sie unter Geschachtelte Kontrollstrukturen.

Exit For und Continue For

Die Exit For-Anweisung beendet sofort die For... Next Überträgt die Steuerung an die Anweisung, die auf die Next Anweisung folgt.

Die Continue For Anweisung überträgt die Steuerung sofort an die nächste Iteration der Schleife. Weitere Informationen finden Sie unter Anweisung fortsetzen.

Im folgenden Beispiel wird die Verwendung der Continue For- und Exit For-Anweisungen veranschaulicht.

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

Sie können eine beliebige Anzahl von Exit For Anweisungen in eine For... Next Loop. Bei Verwendung in geschachtelten For... Next-Schleife, Exit For beendet die innerste Schleife und überträgt die Steuerung auf die nächst höhere Ebene der Schachtelung.

Exit For wird häufig verwendet, nachdem Sie eine Bedingung ausgewertet haben (z. B. in einer If...Then...Else struktur). Möglicherweise möchten Sie für die folgenden Bedingungen verwenden Exit For :

• Die Fortsetzung des Iterierens ist unnötig oder unmöglich. Ein fehlerhafter Wert oder eine Beendigungsanforderung kann diese Bedingung erstellen.

• Ein Try...Catch ...Finally -Anweisung fängt eine Ausnahme ab. Sie können am Ende des Exit For Blocks verwendenFinally.

• Sie haben eine Endlosschleife, die eine große oder sogar unendliche Anzahl von Malen durchlaufen kann. Wenn Sie eine solche Bedingung erkennen, können Sie Exit For verwenden, um die Schleife zu verlassen. Weitere Informationen finden Sie unter Do...Loop-Anweisung.

Technische Implementierung

Wenn eine For...Next-Schleife gestartet wird, wertet Visual Basic start, end und step aus. Visual Basic wertet diese Werte nur zu diesem Zeitpunkt aus und weist dann start an counter zu. Bevor der Anweisungsblock ausgeführt wird, vergleicht Visual Basic counter mit end. Ist counter bereits größer als der Wert von end (oder kleiner, falls step negativ ist), endet die For-Schleife und die Kontrolle geht an die Anweisung über, die auf die Next-Anweisung folgt. Andernfalls wird der Anweisungsblock ausgeführt.

Jedes Mal, wenn Visual Basic auf die Next-Anweisung trifft, wird counter um step erhöht und zur For-Anweisung zurückgekehrt. Es vergleicht erneut counter mit end, und je nach Ergebnis wird entweder der Block ausgeführt oder die Schleife beendet. Dieser Prozess wird fortgesetzt, bis counter Durchläufe end oder eine Exit For Anweisung gefunden wird.

Die Schleife wird erst beendet, wenn counter sie übergeben endwurde. Wenn counter gleich endist, wird die Schleife fortgesetzt. Der Vergleich, der bestimmt, ob der Block ausgeführt werden soll, ist counter<= end, wenn step positiv ist, und counter>= end, wenn step negativ ist.

Wenn Sie den Wert von counter innerhalb einer Schleife ändern, kann Ihr Code schwieriger zu lesen und zu debuggen sein. Das Ändern des Werts von start, end oder step wirkt sich nicht auf die Iterationswerte aus, die beim ersten Betreten der Schleife festgelegt wurden.

Wenn Sie Schleifen schachteln, signalisiert der Compiler einen Fehler, wenn er auf die Next-Anweisung einer äußeren Schachtelungsebene vor der Next-Anweisung einer inneren Ebene stößt. Der Compiler kann diesen überlappenden Fehler jedoch nur erkennen, wenn Sie in jeder counter Anweisung angebenNext.

Schrittargument

Der Wert kann step entweder positiv oder negativ sein. Dieser Parameter bestimmt die Schleifenverarbeitung anhand der nachstehenden Tabelle.

Der Standardwert von step ist 1.

Gegenargument

Die folgende Tabelle zeigt, ob counter eine neue lokale Variable definiert, die die gesamte For…Next Schleife umfasst. Diese Bestimmung hängt davon ab, ob datatype vorhanden ist und ob counter bereits definiert ist.

Der Datentyp von counter bestimmt, welcher Typ der Iteration vorliegt, der einer der folgenden Typen sein muss:

• A Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single, oder Double.

• Eine Aufzählung, die Sie mithilfe einer Enum-Anweisung deklarieren.

• Ein Object-Element.

• Ein Typ T mit den folgenden Operatoren, wobei B es sich um einen Typ handelt, der in einem Boolean Ausdruck verwendet werden kann.

  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

Optional können Sie die counter Variable in der Next Anweisung angeben. Diese Syntax verbessert die Lesbarkeit Ihres Programms, insbesondere, wenn Sie geschachtelte For Schleifen haben. Sie müssen die Variable angeben, die in der entsprechenden For Anweisung angezeigt wird.

Die Ausdrücke start, end und step können auf jeden Datentyp ausgewertet werden, der sich auf den Typ von counter erweitern lässt. Wenn Sie einen benutzerdefinierten Typ für counter verwenden, müssen Sie möglicherweise den Konvertierungsoperator CType definieren, um die Typen von start, end oder step in den Typ von counter zu konvertieren.

Beispiel 1

Im folgenden Beispiel werden alle Elemente aus einer generischen Liste entfernt. Anstelle einer "For Each...Nächste Anweisung" zeigt das Beispiel eine For...Next Anweisung, die in absteigender Reihenfolge iteriert. Im Beispiel wird diese Technik verwendet, da die removeAt Methode dazu führt, dass der Indexwert der nachfolgenden Elemente verringert wird.

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

Beispiel 2

Im folgenden Beispiel wird eine Aufzählung iteriert, die mithilfe einer Enum-Anweisung deklariert wird.

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

Beispiel 3

Im folgenden Beispiel verwenden die Anweisungsparameter eine Klasse mit Operatorüberladungen für die +Operatoren , -, >=und <= Operatoren.

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

Siehe auch

• List<T>
• Schleifenstrukturen
• While...End While-Anweisung
• Do...Loop-Anweisung
• Geschachtelte Steuerungsstrukturen
• Exit-Anweisung
• Sammlungen