For...Next-Anweisung (Visual Basic)

Wiederholt eine Reihe von Anweisungen so oft wie angegeben.

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

Bestandteile

Hinweise

Verwenden Sie eine For...Next-Struktur, wenn ein Satz von Anweisungen mit einer festgelegten Anzahl von Wiederholungen ausgeführt werden soll.

Wenn eine For...Next-Schleife beginnt, wertet Visual Basic start, end und step aus. Dies ist das einzige Mal, dass diese Werte ausgewertet werden. Dann wird start zu counter zugeordnet. Bevor der Anweisungsblock ausgeführt wird, wird counter mit end verglichen. Wenn counter bereits ist größer als der Wert von end ist (oder kleiner, wenn step negativ ist), endet die For-Schleife und die Steuerung wird an die Anweisung nach der Next-Anweisung übergeben. Andernfalls wird der Anweisungsblock ausgeführt.

Visual Basic erhöht bei jedem Auftreten der Next-Anweisung counter um step und kehrt zur For-Anweisung zurück. counter wird erneut mit end verglichen, und wieder wird je nach Ergebnis der Block ausgeführt oder die Schleife verlassen. Dieser Vorgang wird fortgesetzt, bis end von counter übergeben wird oder eine Exit For-Anweisung auftritt.

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

Wenn Sie den Wert von counter während eines Schleifendurchlaufs ändern, wird u. U. das Lesen und Debuggen des Codes erschwert. Das Ändern des Werts von start, end oder step wirkt sich nicht auf die Iterationswerte aus, die zu Beginn der Schleife bestimmt wurden.

Schrittargument

Der Wert von step kann positiv oder negativ sein. Er bestimmt die Schleifenverarbeitung wie folgt:

Falls kein Wert für step angegeben ist, wird standardmäßig 1 verwendet.

Gegenargument

Wenn counter nicht außerhalb dieser Schleife deklariert wurde, müssen Sie es in der For-Anweisung deklarieren. In diesem Fall ist der Gültigkeitsbereich von counter der Rumpf der Schleife. Sie können counter jedoch nicht sowohl außerhalb aus auch innerhalb der Schleife deklarieren.

Sie können counter in der Next-Anweisung optional angeben. Dies verbessert die Lesbarkeit des Programms, besonders, wenn Sie For-Schleifen geschachtelt haben. Sie müssen dieselbe Variable angeben, die in der entsprechenden For-Anweisung vorhanden ist.

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

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

• Eine Enumeration, die Sie mithilfe einer Enum-Anweisung (Visual Basic)deklarieren.

• Ein Object.

• Ein Typ T, der die folgenden Operatoren hat, 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

Die Ausdrücke start, end und step können jeden Datentyp ergeben, der zum Typ von counter erweitert werden kann. Wenn Sie für counter einen benutzerdefinierten Typ verwenden, müssen Sie den CType-Konvertierungsoperator definieren, um die Typen von start, end oder step in den Typ von counter zu konvertieren.

Schachteln von Schleifen

Sie können For-Schleifen schachteln, indem Sie eine Schleife in eine andere einfügen. Jede Schleife erfordert jedoch eine eindeutige counter-Variable.

Sie können auch unterschiedliche Arten von Steuerungsstrukturen ineinander schachteln. Weitere Informationen finden Sie unter Geschachtelte Steuerungsstrukturen (Visual Basic).

Wenn eine Next-Anweisung einer äußeren Schachtelungsebene vor der Next-Anweisung einer inneren Ebene auftritt, signalisiert der Compiler einen Fehler. Der Compiler kann diesen Überlappungsfehler nur erkennen, wenn Sie in jeder Next-Anweisung counter angeben.

Beenden für

Das Exit-Anweisung (Visual Basic) beendet sofort die For…Next-Schleife und übergibt die Steuerung an die Anweisung nach der Next-Anweisung.

Sie können eine beliebige Anzahl von Exit For-Anweisungen in einer For...Next-Schleife einfügen. Bei Verwendung in geschachtelten For...Next-Schleifen beendet Exit For die innerste Schleife und überträgt die Steuerung auf die nächsthöhere Schachtelungsebene.

Exit For wird oft nach der Auswertung einer Bedingung verwendet, z. B. in einer If...Then...Else-Struktur. Sie können Exit For für die folgenden Bedingungen verwenden möchten:

• Das weitere Durchlaufen ist unnötig oder unmöglich. Dies kann durch einen falschen Wert oder eine Beendigungsanforderung verursacht werden.

• Eine Ausnahme wird abgefangen in Try...Catch...Finally. Sie können am Ende des Finally-Blocks Exit For verwenden.

• Dort eine Endlos-Schleife, die eine Schleife ist, die eine große oder sogar unendliche Anzahl von Wiederholungen ausgeführt werden kann. Wenn Sie eine solche Bedingung feststellen, können Sie Exit For verwenden, um die Schleife zu verlassen. Weitere Informationen finden Sie unter Do...Loop-Anweisung (Visual Basic).

Die Continue For-Anweisung überträgt die Steuerung direkt an die nächste Iteration der Schleife. Weitere Informationen finden Sie unter Continue-Anweisung (Visual Basic).

Beispiel

Das folgende Beispiel veranschaulicht die Verwendung der For…Next-Anweisung. Mit jeder Iteration der Schleife wird eine Zählervariable der Schleife erhöht. Das step-Argument ist nicht angegeben, sodass es den Standardwert 1 erhält.

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

Im folgenden Beispiel sind das counter-Argument und das step-Argument Double-Fließkommazahlen.

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 

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 verringert eine Zählervariable der Schleife 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

Das folgende Beispiel entfernt alle Elemente aus einer generischen Liste. Anstelle eines For Each...Next-Anweisung (Visual Basic) wird eine For...Next-Anweisung, die in absteigender Reihenfolge iteriert, verwendet. Dies ist so, weil die removeAt-Methode dazu führt, dass Elemente nach dem entfernte 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

Das folgende Beispiel veranschaulicht die Verwendung der Continue For-Anweisung und der Exit For-Anweisung.

For index As Integer = 1 To 100000
    ' If index is between 5 and 7, continue
    ' with the next iteration.
    If index >= 5 And 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

Im folgenden Beispiel wird eine Enumeration durchlaufen, die mit einem Enum-Anweisung (Visual Basic) deklariert ist.

Public Enum Mammals
    Buffalo
    Gazelle
    Mongoose
    Rhinocerous
    Whale
End Enum


Public Sub ListSomeMammals()
    For mammal As Mammals = Mammals.Gazelle To Mammals.Rhinocerous
        Debug.Write(mammal.ToString & " ")
    Next
    Debug.WriteLine("")
    ' Output: Gazelle Mongoose Rhinocerous
End Sub

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

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

Aufgaben

Gewusst wie: Verbessern der Leistung einer Schleife (Visual Basic)

Referenz

While...End While-Anweisung (Visual Basic)

Do...Loop-Anweisung (Visual Basic)

Exit-Anweisung (Visual Basic)

For Each...Next-Anweisung (Visual Basic)

List<T>

Konzepte

Schleifenstruktur (Visual Basic)

Geschachtelte Steuerungsstrukturen (Visual Basic)

Änderungsprotokoll