Istruzione For...Next (Visual Basic)

Articolo
04/09/2024

Ripete un gruppo di istruzioni un numero specificato di volte.

Sintassi

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

Parti

In parte	Descrizione
`counter`	Obbligatorio nell'istruzione `For`. Variabile numerica. Variabile di controllo per il ciclo. Per altre informazioni, vedere Counter Argument più avanti in questo argomento.
`datatype`	Facoltativo. 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`	Facoltativo. Espressione numerica. Quantità in base alla quale `counter` viene incrementata ogni volta che viene eseguito il ciclo.
`statements`	Facoltativo. Una o più istruzioni tra `For` e `Next` che eseguono il numero specificato di volte.
`Continue For`	Facoltativo. Trasferisce il controllo all'iterazione del ciclo successivo.
`Exit For`	Facoltativo. Trasferisce il controllo fuori dal ciclo `For`.
`Next`	Obbligatorio. Termina la definizione del ciclo `For`.

Nota

La parola chiave To 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 matrice. Per altre informazioni sulle dichiarazioni di matrice, vedere Istruzione Dim.

Esempi semplici

Si usa una struttura For...Next quando si desidera ripetere un set di istruzioni un numero di volte impostato.

Nell'esempio seguente, la variabile index inizia con un valore 1 e viene incrementata con ogni iterazione del ciclo, che termina 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 variabile number inizia a 2 e viene ridotta di 0,25 per ogni iterazione del ciclo, terminando dopo che il valore di number raggiunge 0. L'argomento Step di -.25 riduce il valore di 0,25 per ogni iterazione del ciclo.

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

Un’Istruzione While...End While o Istruzione 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 ciclo For...Next è una scelta migliore. Si determina il numero di iterazioni quando si immette per la prima volta il ciclo.

Cicli di annidamento

È possibile annidare i cicli For inserendone uno all'interno di un altro. Nell'esempio seguente vengono illustrate le strutture annidate For...Next 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 cicli, ogni ciclo deve avere una variabile counter univoca.

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

Esci per e continua per

L'istruzione Exit For esce immediatamente da For…Next esegue il 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 istruzioni Exit For in un For…Ciclo Next. Se usato all'interno di For annidati…Cicli Next, 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 una struttura If...Then...Else). È possibile usare Exit For per le condizioni seguenti:

Non è necessario o impossibile continuare a eseguire l'iterazione. 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 blocco di Finally.
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 eseguire l'escape del ciclo. Per altre informazioni, vedere Istruzione Do...Loop.

Implementazione tecnica

All'avvio di un ciclo For...Next Visual Basic valuta start, end e 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 valore end (o minore se step è negativo), il ciclo For termina e il controllo passa all'istruzione che segue l'istruzione Next. In caso contrario, viene eseguito il blocco delle istruzioni.

Ogni volta che Visual Basic rileva l'istruzione Next, incrementa counter per step e restituisce all'istruzione For. Anche in questo caso, confronta counter con end ed esegue di nuovo il blocco o esce dal ciclo, a seconda del risultato. Questo processo continua fino a quando counter non 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, potrebbe essere più difficile leggere il codice ed eseguirne il debug. La modifica del valore di start, end o step non influisce sui valori di iterazione determinati quando il ciclo è stato immesso per la prima volta.

Se si annidano dei cicli, il compilatore segnala 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 istruzione Next.

Argomento passaggio

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

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

Il valore predefinito di step è 1.

Argomento Contatore

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

`datatype` è presente ?	`counter` è già definito?	Risultato (se `counter` definisce una nuova variabile locale che ha come ambito l'intero ciclo `For...Next`)
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 espressioni `start`, `end` e `step`. Per informazioni sull'inferenza dei tipi, vedere Istruzione dell’inferenza dell’opzione e Inferenza del tipo locale.
Sì	Sì	Sì, ma solo se la variabile `counter` esistente è definita all'esterno della procedura. Tale variabile rimane separata. Se l'ambito della variabile `counter` esistente è 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:

Un oggetto Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single o Double.
Enumerazione dichiarata tramite un'istruzione Enum.
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 variabile counter nell'istruzione Next. Questa sintassi migliora la leggibilità del programma, soprattutto se sono presenti dei cicli For annidati. È necessario specificare la variabile visualizzata nell'istruzione For corrispondente.

Le espressioni start, end e step possono restituire qualsiasi tipo di dati che si estende al tipo di counter. Se si usa un tipo definito dall'utente per counter, potrebbe essere necessario definire l'operatore di conversione CType per convertire i tipi di start, end o 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, l'esempio mostra un'istruzione For...Next che esegue l'iterazione in ordine decrescente. Nell'esempio viene utilizzata questa tecnica perché il metodo removeAt fa sì 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 per gli 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