Részére... Következő utasítás (Visual Basic)

Megismétli az utasítások egy csoportját, miközben a hurokszámláló közeledik a végső értékéhez.

Szemantika

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

Részek

Rész	Leírás
`counter`	A `For` megadása kötelező az utasításban. Numerikus változó. A ciklus vezérlőváltozója. További információ: Ellenvetés a témakör későbbi részében.
`datatype`	Opcionális. Adattípus: `counter`. További információ: Ellenvetés 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éke `counter`.
`step`	Opcionális. Numerikus kifejezés. Az az összeg, amellyel `counter` a cikluson keresztül minden alkalommal növekszik.
`statements`	Opcionális. A `For` és `Next` között található egy vagy több utasítás, amelyek a megadott számú alkalommal futnak le.
`Continue For`	Opcionális. Átviszi a vezérlőt a következő ciklus iterációba.
`Exit For`	Opcionális. A vezérlés átvitele a `For` cikluson kívülre történik.
`Next`	Szükséges. Lezárja a `For` hurok definícióját.

Megjegyzé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 Select... Case utasítás valamint tömbök deklarálásához is használhatja. A tömbdeklarációkról további információt a Dim utasítás-ban talál.

Egyszerű példák

Akkor használ ...For struktúrátNext, 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

Jótanács

Egy While...End While utasítás vagy Do...Loop utasítás akkor működik jól, ha nem tudjuk előre, hányszor kell futtatni az utasításokat a ciklusban. Ha azonban a ciklust meghatározott számú alkalommal szeretné futtatni, Fora ...Next ciklus jobb választás. Amikor először belép a ciklusba, határozza meg az iterációk számát.

Beágyazott hurkok

A For hurkokat egymásba ágyazhatja, ha 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 minden egyes iterációra létrehoz egy karakterláncot. A belső hurok a ciklus minden iterációja esetében csökkenti a 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 egymásba ágyazásakor minden huroknak különálló 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 ciklusból és folytatás a ciklusban

Az Exit For utasítás azonnal kilép a For... Next ciklus, és átviszi az irányítást az utána következő utasításra 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 a Continue For és Exit For utasítások használatát szemlélteti.

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. Amikor beágyazott For-vel/val használják... Next ciklus, Exit For kilép a legbelső hurokból, és átadja az irányítást a következő magasabb szintű beágyazási szintre.

Exit For gyakran használjuk, miután kiértékeltek egy feltételt (például egy If...Then...Else struktúrában). 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. Lehet, hogy a Exit For blokk végén használja a Finally.
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 start-t hozzárendeli counter-hez. Az utasításblokk futtatása előtt a Visual Basic összehasonlítja counter-t end-el. Ha counter már nagyobb, mint az end érték (vagy kisebb, ha step negatív), a For hurok véget ér, és az irányítás az Next utasítást 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, növeli counter értékét step-vel, és visszatér az For utasításhoz. Ismét összehasonlítja a counter és end elemeket, és az eredménytől függően ismét vagy végrehajtja a end blokkot, vagy kilép a ciklusból. Ez a folyamat addig folytatódik, amíg a counter el nem éri a end értéket, vagy egy Exit For utasítással találkozik.

A hurok addig nem áll le, amíg counter meg nem haladta end. Ha counter egyenlő end, az ismétlés folytatódik. Az összehasonlítás, amely meghatározza, hogy a blokk counter< = end-e, ha step pozitív, és counter> = end-e, ha step negatív.

Ha módosítja a `counter` értékét egy cikluson belül, a kód olvasása és hibakeresése nehezebb lehet. A start, end vagy step értékének megváltoztatása nem befolyásolja az iterációs értékeket, amelyeket a ciklus első belépésekor határoztak meg.

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 megadja a counter minden egyes Next utasításban.

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`

A step alapértelmezett értéke 1.

Ellenérv

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` ?	A `counter` már definiálva van?	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 `counter` hatóköre nem helyi az eljáráson belül, fordítási idejű figyelmeztetés jelenik meg.
Nem	Nem	Igen. Az adattípust a `start`, `end` és `step` kifejezésekből következtetik. 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, Integer, ULong, Long, Decimal, Single, vagy Double.
Enumerálás, amelyet enum utasítással deklarál.
Egy Object.
Olyan típus T, amely rendelkezik a következő operátorokkal, ahol a B egy olyan típus, amely Boolean kifejezésben használható.

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 kifejezések bármilyen adattípusra kiértékelhetők, amely a counter típusra szélesedik. Ha felhasználó által definiált típust használ a counter, előfordulhat, hogy meg kell határoznia a CType konverziós operátort, hogy a start, end vagy step típusokat a counter típusba konvertálja.

1. példa

Az alábbi példa eltávolítja az összes elemet egy általános listából. Helyett egy For Each...Next utasítás, a példa egy For...Next utasítást mutat be, 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

Lásd még

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-07-15