For...Next – příkaz (Visual Basic)

Článek
03/05/2024

Zopakuje skupinu příkazů s určeným počtem opakování.

Syntaxe

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

Součástky

Část	Popis
`counter`	Požadováno `For` v příkazu. Číselná proměnná Řídicí proměnná smyčky. Další informace naleznete v části Argument čítače dále v tomto tématu.
`datatype`	Nepovinné. Datový typ `counter`. Další informace naleznete v části Argument čítače dále v tomto tématu.
`start`	Povinný: Číselný výraz. Počáteční hodnota `counter`.
`end`	Povinný: Číselný výraz. Konečná hodnota `counter`.
`step`	Nepovinné. Číselný výraz. Množství, o které `counter` se při každém procházení smyčky zvýší.
`statements`	Nepovinné. Jeden nebo více příkazů mezi `For` zadaným `Next` počtem spuštění.
`Continue For`	Nepovinné. Přenese řízení do další iterace smyčky.
`Exit For`	Nepovinné. Přenese kontrolu mimo smyčku `For` .
`Next`	Povinný: Ukončí definici smyčky `For` .

Poznámka:

Klíčové To slovo se v tomto příkazu používá k určení rozsahu pro čítač. Toto klíčové slovo můžete použít také ve výběru... Case – příkaz a v deklaracích polí Další informace o deklaracích polí naleznete v tématu Dim – příkaz.

Jednoduché příklady

Strukturu ...Next použijeteFor, když chcete opakovat sadu příkazů nastavený početkrát.

V následujícím příkladu index začíná proměnná hodnotou 1 a zvýší se o každou iteraci smyčky, která končí po dosažení index hodnoty 5.

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

V následujícím příkladu number začíná proměnná na 2 a je snížena o 0,25 pro každou iteraci smyčky, končící po dosažení hodnoty number 0. Argument Step-.25 zmenšuje hodnotu o 0,25 pro každou iteraci smyčky.

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

Tip

A While... Ukončit příkaz While nebo Do... Příkaz smyčky funguje dobře, když nevíte, kolikrát se mají příkazy ve smyčce spouštět. Pokud ale očekáváte, že smyčku spustíte určitou dobu, je lepší volbou smyčka For...Next . Počet iterací určíte při prvním zadání smyčky.

Vnoření smyček

Smyčky můžete vnořit For vložením jedné smyčky do jiné. Následující příklad ukazuje vnořené For...Next struktury, které mají různé hodnoty kroku. Vnější smyčka vytvoří řetězec pro každou iteraci smyčky. Vnitřní smyčka dekrementuje proměnnou čítače smyčky pro každou iteraci smyčky.

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

Při vnořování smyček musí mít každá smyčka jedinečnou counter proměnnou.

Můžete také vnořit různé druhy řídicích struktur mezi sebou. Další informace naleznete v tématu Vnořené řídicí struktury.

Ukončit a pokračovat pro

Příkaz Exit For okamžitě ukončí For...Next přenese řízení na příkaz, který následuje za příkazem Next .

Příkaz Continue For okamžitě přenese řízení na další iteraci smyčky. Další informace naleznete v tématu Continue – příkaz.

Následující příklad znázorňuje použití Continue For příkazů a Exit For příkazů.

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

Můžete vložit libovolný počet Exit For příkazů do For...Next Smyčky. Při použití vnořené For...Next smyčky, Exit For ukončí nejvnitřnější smyčku a přenese řízení na další vyšší úroveň vnoření.

Exit For se často používá po vyhodnocení určité podmínky (například v If...Then...Else struktury). Možná budete chtít použít Exit For následující podmínky:

Pokračování v iteraci je zbytečné nebo nemožné. Tuto podmínku může vytvořit chybná hodnota nebo žádost o ukončení.
A Try...Catch...Finally příkaz zachytí výjimku. Můžete použít Exit For na konci Finally bloku.
Máte nekonečnou smyčku, což je smyčka, která by mohla spustit velký nebo dokonce nekonečný početkrát. Pokud takovou podmínku zjistíte, můžete ji použít Exit For k úniku smyčky. Další informace naleznete v tématu Do... Příkaz Loop.

Technická implementace

ForPři spuštění smyčky start...Next jazyka Visual Basic vyhodnotí , enda step. Jazyk Visual Basic vyhodnocuje tyto hodnoty pouze v tuto chvíli a pak přiřadí start .counter Před spuštěním bloku příkazu se Visual Basic porovná counter s end. Pokud counter je již větší než end hodnota (nebo menší, pokud step je záporná), smyčka For skončí a ovládací prvek předá do příkazu, který následuje za příkazem Next . Jinak se blok příkazu spustí.

Pokaždé, když Visual Basic narazí na Next příkaz, zvýší counterstep a vrátí se do For příkazu. Znovu porovná counterends a znovu spustí blok nebo ukončí smyčku v závislosti na výsledku. Tento proces pokračuje, dokud counter neprojde end nebo Exit For se nezjistila příkaz.

Smyčka se nezastaví, dokud counter nepřejde end. Pokud counter je rovno end, smyčka pokračuje. Porovnání, které určuje, zda se má blok spustit, je counter<= end pokud step je kladné a counter>= end pokud step je záporné.

Pokud změníte hodnotu counter uvnitř smyčky, může být čtení a ladění kódu obtížnější. Změna hodnoty parametru start, endnebo step nemá vliv na hodnoty iterace, které byly určeny při prvním zadání smyčky.

Pokud vnořujete smyčky, kompilátor signalizuje chybu, pokud narazí na Next příkaz vnější úrovně vnoření před Next příkazem vnitřní úrovně. Kompilátor však může tuto překrývající se chybu rozpoznat pouze v případě, že zadáte counter v každém Next příkazu.

Argument kroku

Hodnota step může být buď kladná, nebo záporná. Tento parametr určuje zpracování smyčky podle následující tabulky:

Hodnota kroku	Smyčka se spustí, pokud
Kladné nebo nulové	`counter`<= `end`
Záporný	`counter`>= `end`

Výchozí hodnota step je 1.

Argument čítače

Následující tabulka označuje, zda counter definuje novou místní proměnnou, která je vymezena na celou For…Next smyčku. Toto určení závisí na tom, zda datatype je přítomna a zda counter je již definována.

Je `datatype` k dispozici?	Je `counter` už definováno?	Výsledek (jestli `counter` definuje novou místní proměnnou, která je vymezená na celou `For...Next` smyčku)
No	Ano	Ne, protože `counter` je již definován. Pokud rozsah `counter` není místní pro proceduru, dojde k upozornění v době kompilace.
No	Ne	Ano. Datový typ je odvozen z výrazu `start`, `end`a `step` výrazy. Informace o odvození typu naleznete v tématu Příkaz odvození možnosti a odvození místního typu.
Ano	Yes	Ano, ale pouze pokud je existující `counter` proměnná definována mimo proceduru. Tato proměnná zůstává oddělená. Pokud je obor existující `counter` proměnné místní pro proceduru, dojde k chybě v době kompilace.
Yes	No	Ano.

Datový typ counter určuje typ iterace, který musí být jedním z následujících typů:

A Byte, SByte, , UShort, Short, UInteger, ULongIntegerDecimalLong, Singlenebo .Double
Výčet, který deklarujete pomocí výčtového příkazu.
A Object.
Typ T , který má následující operátory, kde B je typ, který lze použít ve výrazu Boolean .

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

Volitelně můžete zadat proměnnou counter v Next příkazu. Tato syntaxe zlepšuje čitelnost programu, zejména pokud máte vnořené For smyčky. Je nutné zadat proměnnou, která se zobrazí v odpovídajícím For příkazu.

Výrazy start, enda step výrazy mohou vyhodnotit na libovolný datový typ, který se rozšiřuje na typ counter. Pokud používáte uživatelem definovaný typ counterpro , možná budete muset definovat operátor převodu CType pro převod typů start, endnebo step na typ counter.

Příklad 1

Následující příklad odebere všechny prvky z obecného seznamu. Místo pro každou... Next Statement, the example shows a For...Next statement that iterates in descending order. Tento příklad používá tuto techniku, protože removeAt metoda způsobí, že prvky po odebrání elementu mají nižší hodnotu indexu.

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

Příklad 2

Následující příklad iteruje prostřednictvím výčtu, který je deklarován pomocí enum Statement.

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

Příklad 3

V následujícím příkladu parametry příkazu používají třídu, která má operátor přetížení pro +, -, >=a <= operátory.

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