Per... Istruzione Next (Visual Basic)

Ripete un gruppo di istruzioni mentre il contatore del ciclo si avvicina al valore finale.

Sintassi

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

Parti

Parte	Descrizione
`counter`	Richiesto nell'istruzione `For`. Variabile numerica. Variabile di controllo per il ciclo. Per altre informazioni, vedere Counter Argument più avanti in questo argomento.
`datatype`	Opzionale. Tipo di dati di `counter`. Per altre informazioni, vedere Counter Argument più avanti in questo argomento.
`start`	Obbligatorio. Espressione numerica. Il valore iniziale di `counter`.
`end`	Obbligatorio. Espressione numerica. Valore finale di `counter`.
`step`	Opzionale. Espressione numerica. Quantità in base alla quale `counter` viene incrementata ogni volta che viene eseguito il ciclo.
`statements`	Opzionale. Una o più istruzioni tra `For` e `Next` che eseguono il numero specificato di volte.
`Continue For`	Opzionale. Trasferisce il controllo all'iterazione del ciclo successivo.
`Exit For`	Opzionale. Trasferisce il controllo fuori dal `For` ciclo.
`Next`	Obbligatorio. Termina la definizione del `For` ciclo.

Annotazioni

La To parola chiave viene utilizzata in questa istruzione per specificare l'intervallo per il contatore. È anche possibile usare questa parola chiave nell'istruzione Select...Case e nelle dichiarazioni di array. Per ulteriori informazioni sulle definizioni di array, vedere Istruzione Dim.

Esempi semplici

Si utilizza una struttura For...Next quando si desidera ripetere un insieme di istruzioni un numero prestabilito di volte.

Nell'esempio seguente la index variabile inizia con un valore pari a 1 e viene incrementata con ogni iterazione del ciclo, terminando dopo che il valore di index raggiunge 5.

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

Nell'esempio seguente la number variabile inizia da 2 e viene ridotta di 0,25 per ogni iterazione del ciclo, terminando dopo che il valore di number raggiunge 0. A ogni iterazione del ciclo, l'argomento Step di -.25 riduce il valore di 0,25.

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

Suggerimento

Una dichiarazione While...End While o dichiarazione Do...Loop funziona correttamente quando non si sa in anticipo quante volte eseguire le istruzioni nel ciclo. Tuttavia, quando si prevede di eseguire il ciclo un numero specifico di volte, un Forciclo ...Next è una scelta migliore. Si determina il numero di iterazioni quando si immette per la prima volta il ciclo.

Cicli di annidamento

È possibile annidare For i cicli inserendo un ciclo all'interno di un altro. Nell'esempio seguente vengono illustrate le strutture annidate ForNext con valori di passaggio diversi. Il ciclo esterno crea una stringa per ogni iterazione del ciclo. Il ciclo interno decrementa una variabile del contatore del ciclo per ogni iterazione del ciclo.

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

Quando si annidano i cicli, ogni ciclo deve avere una variabile univoca counter.

È anche possibile annidare strutture di controllo di tipi diversi tra loro. Per altre informazioni, vedere Strutture di controllo annidate.

Esci da For e Continua con For

L'istruzione Exit For esce immediatamente da For... Next loop e trasferisce il controllo all'istruzione che segue l'istruzione Next .

L'istruzione Continue For trasferisce immediatamente il controllo all'iterazione successiva del ciclo. Per altre informazioni, vedere istruzione 'Continue'.

Nell'esempio seguente viene illustrato l'uso delle istruzioni Continue For e Exit 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

È possibile inserire un numero qualsiasi di Exit For istruzioni in un For... Next ciclo. Se usato all'interno di un elemento annidato For... Next cicli, Exit For esce dal ciclo più interno e trasferisce il controllo al livello superiore successivo di annidamento.

Exit For viene spesso usato dopo aver valutato una condizione (ad esempio, in un If...Then...Else struttura). È possibile usare Exit For per le condizioni seguenti:

Continuare a iterare è inutile o impossibile. Un valore errato o una richiesta di terminazione potrebbe creare questa condizione.
Un'istruzione Try...Catch...Finally rileva un'eccezione. È possibile usare Exit For alla fine del Finally blocco.
Si dispone di un ciclo infinito, che è un ciclo che potrebbe eseguire un numero elevato o persino infinito di volte. Se si rileva una condizione di questo tipo, è possibile usare Exit For per uscire dal ciclo. Per ulteriori informazioni, vedere Istruzione Do...Loop.

Implementazione tecnica

All'avvio di un Forciclo ...Next Visual Basic valuta start, ende step. Visual Basic valuta questi valori solo in questo momento e quindi assegna start a counter. Prima dell'esecuzione del blocco di istruzioni, Visual Basic confronta counter con end. Se counter è già maggiore del end valore (o minore se step è negativo), il For ciclo termina e il controllo passa all'istruzione che segue l'istruzione Next . In caso contrario, viene eseguito il blocco di istruzioni.

Ogni volta che Visual Basic rileva l'istruzione Next, incrementa counter di step e torna all'istruzione For. Anche in questo caso viene confrontato counter con ende anche in questo caso esegue il blocco o esce dal ciclo, a seconda del risultato. Questo processo continua fino a quando counter supera end o viene rilevata un'istruzione Exit For.

Il ciclo non si arresta finché counter non viene passato end. Se counter è uguale a end, il ciclo continua. Il confronto che determina se eseguire il blocco è counter<= end se step è positivo e counter>= end se step è negativo.

Se si modifica il valore di counter durante un ciclo, il codice potrebbe essere più difficile da leggere ed eseguire il debug. La modifica del valore di start, endo step non influisce sui valori di iterazione determinati quando il ciclo è stato immesso per la prima volta.

Se annidate dei cicli, il compilatore segnalerà un errore se rileva l'istruzione Next di un livello di annidamento esterno prima dell'istruzione Next di un livello interno. Tuttavia, il compilatore può rilevare questo errore sovrapposto solo se si specifica counter in ogni Next istruzione.

Argomento del passaggio

Il valore di step può essere positivo o negativo. Questo parametro determina l'elaborazione del ciclo in base alla tabella seguente:

Valore di passo	Il ciclo viene eseguito se
Positivo o zero	`counter` <= `end`
Negativa	`counter` >= `end`

Il valore predefinito di step è 1.

Controargomentazione

La tabella seguente indica se counter definisce una nuova variabile locale con ambito per l'intero For…Next ciclo. Questa determinazione dipende dal fatto che datatype sia presente e che counter sia già definito.

È `datatype` presente?	È `counter` già definito?	Risultato (se `counter` definisce una nuova variabile locale con ambito per l'intero `For...Next` ciclo)
NO	Sì	No, perché `counter` è già definito. Se l'ambito di `counter` non è locale per la procedura, si verifica un avviso in fase di compilazione.
NO	NO	Sì. Il tipo di dati viene dedotto dalle `start`espressioni , `end`e `step` . Per informazioni sull'inferenza dei tipi, vedere Option Infer Statement e Local Type Inference.
Sì	Sì	Sì, ma solo se la variabile esistente `counter` è definita all'esterno della procedura. Tale variabile rimane separata. Se l'ambito della variabile esistente `counter` è locale per la routine, si verifica un errore in fase di compilazione.
Sì	NO	Sì.

Il tipo di dati di counter determina il tipo di iterazione, che deve essere uno dei tipi seguenti:

Oggetto Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single, o Double.
Enumerazione dichiarata tramite un'istruzione Enum.
Un oggetto Object.
Tipo T con gli operatori seguenti, dove B è un tipo che può essere usato in un'espressione 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

Facoltativamente, è possibile specificare la counter variabile nell'istruzione Next . Questa sintassi migliora la leggibilità del programma, soprattutto se sono presenti cicli annidati For . È necessario specificare la variabile visualizzata nell'istruzione corrispondente For .

Le espressioni start, end, e step possono valutare qualsiasi tipo di dati che si amplia fino al tipo di counter. Se si usa un tipo definito dall'utente per counter, potrebbe essere necessario definire l'operatore CType di conversione per convertire i tipi di start, endo step nel tipo di counter.

Esempio 1

Nell'esempio seguente vengono rimossi tutti gli elementi da un elenco generico. Invece di un'istruzione For Each... Next Statement, l'esempio mostra un'istruzione For...Next che esegue l'iterazione in ordine decrescente. Nell'esempio viene utilizzata questa tecnica perché il removeAt metodo fa in modo che gli elementi dopo l'elemento rimosso abbiano un valore di indice inferiore.

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

Esempio 2

Nell'esempio seguente viene eseguita l'iterazione di un'enumerazione dichiarata tramite un'istruzione Enum.

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

Esempio 3

Nell'esempio seguente i parametri dell'istruzione usano una classe con overload degli operatori +, -, >=, e <=.

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

Vedere anche

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-07-15