A... Következő utasítás (Visual Basic)

Cikk
03/13/2024

Megadott számú utasításcsoportot ismétel meg.

Syntax

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

Részek

Része	Leírás
`counter`	Az utasításban `For` kötelező megadni. Numerikus változó. A ciklus vezérlőváltozója. További információ: Számláló argumentuma a témakör későbbi részében.
`datatype`	Opcionális. Adattípus: `counter`. További információ: Számláló argumentuma a témakör későbbi részében.
`start`	Szükséges. Numerikus kifejezés. A kezdeti érték.`counter`
`end`	Szükséges. Numerikus kifejezés. A végleges érték.`counter`
`step`	Opcionális. Numerikus kifejezés. Az az összeg, amellyel `counter` a cikluson keresztül minden alkalommal növekszik.
`statements`	Opcionális. Egy vagy több utasítás között `For` , amely `Next` a megadott számú alkalommal fut.
`Continue For`	Opcionális. Átviszi a vezérlőt a következő ciklus iterációba.
`Exit For`	Opcionális. Az átvitel vezérlése a `For` cikluson kívülre történik.
`Next`	Szükséges. Leállítja a hurok definícióját `For` .

Feljegyzés

Ebben To az utasításban a kulcsszó a számláló tartományának megadására szolgál. Ezt a kulcsszót a Kiválasztás... Esetkimutatás és tömbdeklarációkban. A tömbdeklarációkról további információt a Dim Utasítás című témakörben talál.

Egyszerű példák

Akkor használ ...Next struktúrátFor, ha egy utasításkészletet több alkalommal szeretne megismételni.

Az alábbi példában a index változó 1 értékkel kezdődik, és a ciklus minden iterációjával növekszik, és az 5-ös érték index elérése után végződik.

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

A következő példában a number változó 2-nél kezdődik, és a ciklus minden iterációján 0,25-re csökken, és a 0-ás érték number elérése után végződik. Az Step argumentum -.25 0,25-ével csökkenti az értéket a ciklus minden iterációján.

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.

Egy darabig... Záró utasítás vagy teendő... A Loop Utasítás akkor működik jól, ha nem tudja előre, hogy hányszor futtassa az utasításokat a ciklusban. Ha azonban a ciklust meghatározott számú alkalommal szeretné futtatni, Fora ...Next ciklus jobb választás. A ciklus első megadásakor határozza meg az iterációk számát.

Hurkok beágyazása

Hurkokat úgy ágyazhat be For , hogy az egyik hurkot egy másikba helyezi. Az alábbi példa olyan beágyazott For...Next struktúrákat mutat be, amelyek különböző lépésértékekkel rendelkeznek. A külső hurok létrehoz egy sztringet a ciklus minden iterációja számára. A belső hurok a ciklus minden iterációja esetében lecsuk egy hurokszámláló változót.

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

Hurkok beágyazásakor minden huroknak egyedi counter változóval kell rendelkeznie.

Különböző típusú vezérlőstruktúrák is beágyazhatók egymásba. További információ: Beágyazott vezérlőstruktúrák.

Kilépés a következőhöz:

Az Exit For utasítás azonnal kilép a For...Next ciklust, és átviszi az irányítást az utasítást követő utasításba Next .

Az Continue For utasítás azonnal átviszi a vezérlést a ciklus következő iterációjába. További információ: Folytatási utasítás.

Az alábbi példa az és az utasítások használatát szemlélteti Continue ForExit 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

Tetszőleges számú Exit For utasítást elhelyezhet egy For...Next Hurok. ForBeágyazott ...Next ciklusok, Exit For kilép a legbelső hurok és átviszi az irányítást a következő magasabb szintű beágyazás.

Exit For gyakran használják, miután kiértékelt egy feltételt (például egy If...Then...Else struktúra). A következő feltételek teljesülése esetén érdemes lehet használnia Exit For :

Az iteráció folytatása szükségtelen vagy lehetetlen. Ezt a feltételt hibás érték vagy megszüntetési kérelem hozhatja létre.
Egy Try...Catch...Finally utasítás kivételt jelez. Exit For Használhatja a blokk végénFinally.
Végtelen hurokkal rendelkezik, amely egy olyan hurok, amely nagy vagy akár végtelen számú alkalommal is futtatható. Ha észlel egy ilyen feltételt, akkor a hurok megkerülésére is használhatja Exit For . További információ: Do... Ciklusutasítás.

Technikai megvalósítás

Amikor egy For...Next ciklus elindul, a Visual Basic kiértékeli start, endés step. A Visual Basic csak ebben az időpontban értékeli ki ezeket az értékeket, majd hozzárendeli start őket.counter Az utasításblokk futtatása előtt a Visual Basic összehasonlítja a következővel counterend: . Ha counter már nagyobb, mint az end érték (vagy kisebb, ha step negatív), a hurok véget ér, és a For vezérlőelem az utasítást Next követő utasításra kerül. Ellenkező esetben az utasításblokk fut.

Minden alkalommal, amikor a Visual Basic találkozik az Next utasítással, az fokozatosan növekszik counterstep , és visszatér az For utasításhoz. Az eredménytől függően ismét a counterendblokkot futtatja, vagy kilép a ciklusból. Ez a folyamat mindaddig folytatódik, amíg el nem counter ér end egy utasítást Exit For .

A hurok addig nem áll le, amíg counter el nem telt end. Ha counter egyenlő end, a hurok folytatódik. Az összehasonlítás, amely meghatározza, hogy a blokk counter<futtatása = end ha step pozitív, és counter>= end ha step negatív.

Ha módosítja a cikluson belüli értékeket, a kód olvasása counter és hibakeresése nehezebb lehet. A ciklus endelső beírásakor startmeghatározott iterációs értékek módosítása vagy step módosítása.

Hurkok beágyazása esetén a fordító hibát jelez, ha egy Next külső beágyazási szint utasításával találkozik a Next belső szint utasítása előtt. A fordító azonban csak akkor képes észlelni ezt az átfedésben lévő hibát, ha minden Next utasításban meg van advacounter.

Lépés argumentuma

Az érték step lehet pozitív vagy negatív. Ez a paraméter a ciklusfeldolgozást az alábbi táblázat szerint határozza meg:

Lépésérték	A ciklus akkor fut, ha
Pozitív vagy nulla	`counter`<= `end`
Negatív	`counter`>= `end`

Az alapértelmezett érték step 1.

Számláló argumentum

Az alábbi táblázat azt jelzi, hogy egy új helyi változót határoz-e counter meg, amely a teljes For…Next ciklusra terjed ki. Ez a meghatározás attól függ, hogy van-e datatype jelen, és hogy már definiálva van-e counter .

Jelen van `datatype` ?	Már definiálva van `counter` ?	Eredmény (hogy definiál-e `counter` egy új helyi változót, amely a teljes `For...Next` ciklusra terjed ki)
Nem	Igen	Nem, mert `counter` már definiálva van. Ha az eljárás hatóköre `counter` nem helyi, fordítási idő figyelmeztetés jelenik meg.
Nem	Nem	Igen. Az adattípus a , `end`és `step` a `start`kifejezésekből következtet. A típuskövetkeztetésről további információt az Option Infer Utasítás és a Helyi típus következtetése című témakörben talál.
Igen	Igen	Igen, de csak akkor, ha a meglévő `counter` változó az eljáráson kívül van definiálva. Ez a változó külön marad. Ha a meglévő `counter` változó hatóköre helyi az eljáráshoz, fordítási időhiba lép fel.
Igen	Nem	Igen.

Az adattípus counter határozza meg az iteráció típusát, amelynek az alábbi típusok egyikének kell lennie:

A Byte, SByte, UShort, Short, UInteger, IntegerULong, , Long, Decimal, Singlevagy Double.
Enumerálás, amelyet enum utasítással deklarál.
Egy Object.
Olyan típus T , amely a következő operátorokat tartalmazza, ahol B egy kifejezésben Boolean használható típus.

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

Igény szerint megadhatja a változót counter az Next utasításban. Ez a szintaxis javítja a program olvashatóságát, különösen beágyazott For hurkok esetén. Meg kell adnia a megfelelő For utasításban megjelenő változót.

A start, endés step a kifejezés bármilyen adattípusra kiértékelhető, amely a típusra szélesedik counter. Ha felhasználó által definiált típust counterhasznál, előfordulhat, hogy meg kell határoznia a CType konverziós operátort a típus startendstep vagy a típus konvertálásáhozcounter.

1. példa

Az alábbi példa eltávolítja az összes elemet egy általános listából. Minden egyes helyett... A következő utasítás egy ...Next utasítást mutat beFor, amely csökkenő sorrendben iterál. A példa azért használja ezt a technikát, mert a removeAt metódus az eltávolított elem utáni elemek alacsonyabb indexértéket eredményez.

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

2. példa

Az alábbi példa egy Enum utasítással deklarált enumeráláson keresztül halad végig.

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

3. példa

Az alábbi példában az utasításparaméterek olyan osztályt használnak, amely operátorok túlterhelésével rendelkezik a +, -, >=és <= operátorok esetében.

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