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

Opakuje skupinu příkazů, zatímco čítač smyčky se blíží konečné hodnotě.

Syntaxe

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

Součástky

Část	Popis
counter	V příkazu For je požadováno. Číselná proměnná Řídicí proměnná pro smyčku. Další informace naleznete v části Kontrargument dále v tomto tématu.
datatype	Volitelný. Datový typ counter. Další informace naleznete v části Kontrargument 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	Volitelný. Číselný výraz. Množství, o které se counter zvýší při každém průchodu smyčkou.
statements	Volitelný. Jeden nebo více příkazů mezi For a Next, které se provedou zadaný početkrát.
Continue For	Volitelný. Přenese řízení do další iterace smyčky.
Exit For	Volitelný. 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é v Select...Case příkaz a pro deklarace polí. Další informace o deklaracích polí naleznete v tématu Dim – příkaz.

Jednoduché příklady

Strukturu For...Next použijete, když chcete opakovat sadu příkazů určitý 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 

Návod

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čitý početkrát, je lepší volbou smyčka For...Next. Počet iterací určíte při prvním vstupu do smyčky.

Vnoření smyček

Smyčky můžete vnořit For umístění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 cyklus a 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 Statement.

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čka. Při použití ve vnořeném 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 pro 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 běžet velký počet nebo dokonce nekonečný početkrát. Pokud zjistíte takovou podmínku, můžete použít Exit For k přerušení smyčky. Další informace naleznete v tématu Do...Loop.

Technická implementace

ForKdyž se smyčka Next...start spustí, Visual Basic vyhodnotí end a step. Jazyk Visual Basic vyhodnocuje tyto hodnoty pouze nyní a pak přiřadí start k counter. Před spuštěním bloku příkazu se Visual Basic porovná counter s end. Pokud counter je již větší než hodnota end (nebo menší, pokud je step záporné), smyčka For skončí a řízení přejde na příkaz, který následuje po příkazu Next. Jinak se blok příkazu spustí.

Pokaždé, když Visual Basic narazí na Next příkaz, zvýší counter o step a vrátí se k For příkazu. Opět porovná counter a end, a podle výsledku buď spustí blok, nebo ukončí smyčku. Tento proces pokračuje, dokud counter neprojde end nebo nedojde k Exit For příkazu.

Smyčka se nezastaví, dokud counter nepřejde end. Pokud je counter 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.

Protiargument

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)
Ne	Ano	Ne, protože counter je již definován. Pokud rozsah counter není místní pro proceduru, dojde k upozornění v době kompilace.
Ne	Ne	Ano. Datový typ je odvozen z výrazů start, end, a step. Informace o odvození typu naleznete v tématu Příkaz Option Infer a Místní odvozování typu.
Ano	Ano	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.
Ano	Ne	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, Integer, ULong, Long, Decimal, Single, nebo Double.

• Výčet, který deklarujete pomocí Enum Statement.

• Nějaký 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, end a step mohou být vyhodnoceny 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 For Each...Next Statement, příklad ukazuje příkaz For...Next, který iteruje v sestupném pořadí. 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

Viz také

• List<T>
• Struktury cyklu
• Zatímco... End While – příkaz
• Dělat... Příkaz Loop
• Vnořené řídicí struktury
• Příkaz Exit
• kolekce