For...Next-Anweisung (Visual Basic)

Artikel
03/26/2013

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 ]

Teile

Bestandteil	Beschreibung
counter	In der For-Anweisung erforderlich.Numerische Variable.Die Steuerelementvariable für die Schleife.Weitere Informationen finden Sie unter Gegenargument weiter unten in diesem Thema.
datatype	Dies ist optional.Vom Datentyp counter.Weitere Informationen finden Sie unter Gegenargument weiter unten in diesem Thema.
start	Erforderlich.Ein numerischer Ausdruck.Der Anfangswert von counter.
end	Erforderlich.Ein numerischer Ausdruck.Der Endwert von counter.
step	Dies ist optional.Ein numerischer Ausdruck.Der Wert, um den counter mit jeder durchlaufenen Schleife erhöht wird.
statements	Dies ist optional.Eine oder mehrere Anweisungen zwischen For und Next, die mit der angegebenen Anzahl von Wiederholungen ausgeführt werden.
Continue For	Dies ist optional.Übergibt die Steuerung an die nächste Schleifeniteration.
Exit For	Dies ist optional.Überträgt die Steuerung aus der For-Schleife.
Next	Erforderlich.Beendet die Definition der For-Schleife.

Hinweis
Das To-Schlüsselwort wird in dieser Anweisung verwendet, um den Bereich für den Indikator anzugeben.Sie können dieses Schlüsselwort in Select...Case-Anweisung (Visual Basic) und in den Arraydeklarationen auch verwenden.Weitere Informationen zu Arraydeklarationen finden Sie unter Dim-Anweisung (Visual Basic).

Einfache Beispiele

Sie verwenden eine Struktur For...Next, wenn Sie eine Gruppe von Anweisungen ein festgelegte Häufigkeit wiederholen möchten.

Im folgenden Beispiel wird die index-Variablenanfänge mit einem Wert von 1 und bei jeder Iteration der Schleife erhöht und beendet nach dem Wert von index gezogene 5.

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

Im folgenden Beispiel wird die number-Variablenbeginnung mit 2 und mit 0,25 für jede Iteration der Schleife reduziert und beendet nach dem Wert von number gezogene 0.Das Step-Argument von -.25 reduziert den Wert von 0,25 für jede Iteration der Schleife.

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
Arbeiten While...End While-Anweisung (Visual Basic) oder Do...Loop-Anweisung (Visual Basic) gut, wenn Sie nicht vorhersagen, wie viele Male, die Anweisungen in der Schleife auszuführen.Wenn die Schleife jedoch eine festgelegte Anzahl von Wiederholungen durchlaufen soll, eignet sich eineFor...Next-Schleife besser.Sie bestimmen die Anzahl der Iterationen zu Beginn der Schleife.

Schachteln von Schleifen

Sie können For-Schleifen schachteln, indem Sie eine Schleife in eine andere einfügen.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

Wenn geschachtelte Schleifen, jede - Schleife eine eindeutige counter-Variable benötigen.

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

Beenden für und Fortfahren für fort

Die Exit For-Anweisung beendet sofort die Schleife For...Next und das Übergibt die Steuerung an die Anweisung, die der Next-Anweisung folgt.

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).

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

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 häufig verwendet, nachdem Sie eine Bedingung auswerten, (beispielsweise in einer Struktur If...Then...Else ).Sie können Exit For für die folgenden Bedingungen verwenden möchten:

Das weitere Durchlaufen ist unnötig oder unmöglich.Ein fehlerhafter Wert oder eine Abschlussanforderung könnten diese Bedingung.
Eine Anweisung Try...Catch...Finally fängt eine Ausnahme ab.Sie können am Ende des Finally-Blocks Exit For verwenden.
Sie haben eine Endlosschleife, die eine Schleife ist, die eine große oder sogar unbegrenzte Häufigkeit ausführen konnte.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).

Technische Implementierung

Wenn eine For...Next-Schleife beginnt, wertet Visual Basic start, end und step aus.Visual Basic wertet diese Werte nur derzeit aus und weist dann counterstart zu.Bevor der Anweisungsblock ausgeführt wird, vergleicht Visual Basic counter zu end.Wenn counter bereits größer als ist, der end-Wert (oder das weniger, wenn step negativ ist), die For-Schleifenenden und die die Steuerung an die Anweisung, die der Next-Anweisung folgt.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 nicht auf, bis counterend übergeben hat.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 innerhalb einer Schleife ändern, kann der Code schwieriger zu lesen und zu debuggen.Ein Wert von start ändern, wirkt sich end oder step nicht die Iterationswerte, die bestimmt wurden, als die Schleife zuerst eingeführt wurde.

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

Schrittargument

Der Wert von step kann positiv oder negativ sein.Dieser Parameter bestimmt die Schleife, die entsprechend der folgenden Tabelle verarbeitet:

Step-Wert	Schleifenausführung, wenn
Positiv oder 0	counter <= end
Negativ	counter >= end

Der Standardwert von step ist 1 (null).

Gegenargument

Die folgende Tabelle gibt an, ob counter eine neue lokale Variable definiert, die in der gesamten For…Next-Schleife ausgewertet wird.Diese Angabe hängt davon ab, ob datatype vorhanden ist und ob counter bereits definiert ist.

Ein vorhandenes datatype ?	Der wird counter bereits definiert?	Ergebnis (ob counter eine neue lokale Variable definiert, die in der gesamten For...Next-Schleife erstreckt)
Nein	Ja	Nein, da counter bereits definiert ist.Wenn der Bereich von counter nicht zur Prozedur lokal ist, tritt eine Warnung zur Kompilierzeit auf.
Nein	Nein	Ja.Der Datentyp wird von start, von end und von step Ausdrücken abgeleitet.Informationen zum Typrückschluss, finden Sie unter Option Infer-Anweisung und Lokaler Typrückschluss (Visual Basic).
Ja	Ja	Ja, aber nur, wenn die vorhandene counter-Variable außerhalb der Prozedur definiert ist.Diese Variable bleibt separat.Wenn der Bereich der vorhandenen counter-Variable zur Prozedur lokal ist, tritt ein Kompilierungsfehler auf.
Ja	Nein	Ja.

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

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

Sie können die counter-Variable in der Anweisung Next optional angeben.Diese Syntax verbessert die Lesbarkeit des Programms, insbesondere wenn Sie For-Schleifen geschachtelt haben.Sie müssen die Variable angeben, die in der entsprechenden For-Anweisung auftritt.

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

Beispiel

Das folgende Beispiel entfernt alle Elemente aus einer generischen Liste.Anstatt For Each...Next-Anweisung (Visual Basic) zeigt das Beispiel eine Anweisung For...Next an, die in absteigender Reihenfolge durchlaufen wird.Im Beispiel wird diese Technik, da die removeAt-Methode Elemente nach dem entfernten Element bewirkt, dass einen niedrigeren Indexwert verfügen.

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

Im folgenden Beispiel wird durch eine Enumeration von, die deklariert wird, indem Enum-Anweisung (Visual Basic) verwendet.

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

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