For...Next-Anweisung (Visual Basic)

Wiederholt eine Gruppe von Anweisungen in einer angegebenen Anzahl von Anweisungen.

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 mehrmals wiederholen möchten.

Im folgenden Beispiel beginnt die index-Variable mit dem Wert 1 und wird mit jeder Iteration der Schleife erhöht und endet, nachdem der Wert von index 5 erreicht hat.

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 number-Variable bei 2 und wird bei jeder Iteration der Schleife um 0,25 verringert, wobei sie endet, wenn 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. Im folgenden Beispiel werden geschachtelte For...Next -Strukturen mit unterschiedlichen Schrittwerten veranschaulicht. Die äußere Schleife erstellt eine Zeichenfolge für jede Iteration der Schleife. Die innere Schleife dekrementiert 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 Schachteln von Schleifen muss jede Schleife über eine eindeutige counter-Variable verfügen.

Sie können auch verschiedene Arten von Steuerungsstrukturen ineinander schachteln. Weitere Informationen finden Sie unter Geschachtelte Steuerelementstrukturen.

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 direkt an die nächste Iteration der Schleife. Weitere Informationen finden Sie unter Anweisung fortsetzen.

Das folgende Beispiel veranschaulicht die Verwendung der Anweisungen Continue For und 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

Sie können eine beliebige Anzahl von Exit For Anweisungen in eine For...Next-Schleife. 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 oft verwendet, nachdem Sie eine Bedingung ausgewertet haben (zum Beispiel in einer If...Then... Else-Struktur). Sie können für die folgenden Bedingungen verwenden Exit For:

• Die Fortsetzung des Iterierens ist unnötig oder unmöglich. Diese Bedingung kann durch einen fehlerhaften Wert oder eine Beendigungsanforderung erstellt werden.

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

• Sie haben eine Endlosschleife, bei der es sich um eine Schleife handelt, die eine große oder sogar unendliche Anzahl von Malen ausführen kann. Wenn Sie eine solche Bedingung erkennen, können Exit For Sie verwenden, um die Schleife zu escapen. Weitere Informationen finden Sie unter Do...Loop-Anweisung.

Technische Implementierung

Wenn eine For...-Next Schleife gestartet wird, wertet startVisual Basic , endund stepaus. Visual Basic wertet diese Werte nur zu diesem Zeitpunkt aus und weist start dann zu counter. Bevor der Anweisungsblock ausgeführt wird, vergleicht counter Visual Basic mit end. Wenn counter bereits größer als der end Wert (oder kleiner ist, wenn step negativ) ist, endet die For Schleife und das Steuerelement wird an die Anweisung übergeben, die der Next Anweisung folgt. Andernfalls wird der Anweisungsblock ausgeführt.

Jedes Mal, wenn Visual Basic auf die Next-Anweisung stößt, erhöht counter sie um step und kehrt zur For-Anweisung zurück. Wieder wird mit counterverglichenend, 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 und counter>= end wenn step negativ.

Wenn Sie den Wert von counter in einer Schleife ändern, ist ihr Code möglicherweise schwieriger zu lesen und zu debuggen. Das Ändern des Werts von start, endoder step wirkt sich nicht auf die Iterationswerte aus, die bei der erstmaligen Eingabe der Schleife ermittelt 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 Next-Anweisung angebencounter.

Schrittargument

Die Werte für step können positiv oder negativ sein. Dieser Parameter bestimmt die Schleifenverarbeitung gemäß der folgenden Tabelle:

Der Standardwert von step ist 1.

Zählerargument

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

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

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

• Eine Enumeration, die Sie mithilfe einer Enum-Anweisung deklarieren.

• Object.

• Ein Typ T mit den folgenden Operatoren, wobei B ein Typ ist, 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 über geschachtelte For-Schleifen verfügen. Sie müssen die Variable angeben, die in der entsprechenden For-Anweisung angezeigt wird.

Die Ausdrücke start, end und step können zu einem beliebigen Datentyp ausgewertet werden, der auf den Typ counter erweitert wird. Wenn Sie einen benutzerdefinierten Typ für counterverwenden, müssen Sie möglicherweise den CType Konvertierungsoperator 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 eines For Each... Next-Anweisung, das Beispiel zeigt eine For...Next -Anweisung, die in absteigender Reihenfolge durchläuft. Im Beispiel wird diese Technik verwendet, da die removeAt-Methode bewirkt, dass Elemente nach dem entfernten Element einen niedrigeren Indexwert haben.

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 Enumeration durchlaufen, 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, die Operatorüberladungen für die Operatoren +, -, >= und <= aufweist.

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