For...Next-Anweisung (Visual Basic)

Artikel
06/21/2023

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

Teil	Beschreibung
`counter`	In der `For`-Anweisung erforderlich. Numerische Variable. Die Steuerelementvariable für die Schleife. Weitere Informationen finden Sie unter Zählerargument weiter unten in diesem Thema.
`datatype`	Optional. Datentyp von `counter`. Weitere Informationen finden Sie unter Zählerargument weiter unten in diesem Thema.
`start`	Erforderlich. Ein numerischer Ausdruck. Der Anfangswert von `counter`.
`end`	Erforderlich. Ein numerischer Ausdruck. Der endgültige Wert von `counter`.
`step`	Optional. Ein numerischer Ausdruck. Der Betrag, um den `counter` jedes Mal durch die Schleife erhöht wird.
`statements`	Optional. Mindestens eine Anweisung zwischen `For` und `Next` , die die angegebene Anzahl von Ausführungen ausführt.
`Continue For`	Optional. Überträgt die Steuerung an die nächste Schleifeniteration.
`Exit For`	Optional. Überträgt die Steuerung aus dem `For`-Schleife.
`Next`	Erforderlich. Beendet die Definition des `For`-Schleife.

Hinweis

Der To-Schlüsselwort (keyword) wird in dieser Anweisung verwendet, um den Bereich für den Zähler anzugeben. Sie können diese Schlüsselwort (keyword) auch im ... Case Statement und in Arraydeklarationen. Weitere Informationen zu Arraydeklarationen finden Sie unter Dim-Anweisung.

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

Tipp

Eine While... End While-Anweisung oder Do...Loop-Anweisung funktioniert gut, wenn Sie im Voraus nicht wissen, wie oft die Anweisungen in der Schleife ausgeführt werden sollen. Wenn Sie jedoch erwarten, dass die Schleife eine bestimmte Anzahl von Malen ausgeführt wird, ist eine For...Next-Schleife die bessere Wahl. Sie bestimmen die Anzahl der Iterationen, wenn Sie zum ersten Mal in die Schleife eintreten.

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:

Schrittwert	Schleife wird ausgeführt, wenn
Positiv oder 0	`counter`<= `end`
Negativ	`counter`>= `end`

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.

Ist `datatype` vorhanden?	`counter` ist bereits definiert.	Result (gibt an, ob `counter` eine neue lokale Variable definiert, die auf die gesamte `For...Next`-Schleife beschränkt ist)
Nein	Ja	Nein, da `counter` bereits definiert ist. Wenn der Bereich von `counter` nicht lokal für die Prozedur ist, wird eine Kompilierzeitwarnung angezeigt.
Nein	Nein	Ja. Der Datentyp wird aus den Ausdrücken `start`, `end`und `step` abgeleitet. Weitere Informationen zum Typrückschluss finden Sie unter Option Infer-Anweisung und Lokaler Typrückschluss.
Ja	Ja	Ja, aber nur, wenn die vorhandene `counter` Variable außerhalb der Prozedur definiert ist. Diese Variable bleibt getrennt. Wenn der Bereich der vorhandenen `counter`-Variablen für die Prozedur lokal ist, tritt ein Kompilierzeitfehler auf.
Ja	Nein	Ja.

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