Istruzione For...Next (Visual Basic)

Consentono di ripetere un gruppo di istruzioni per il numero di volte specificato.

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

Parti

Note

Per ripetere un set di istruzioni per il numero di volte specificato, utilizzare una struttura For...Next.

Quando viene avviato un ciclo For...Next, in Visual Basic vengono restituiti start, end e step. Si tratta dell'unico caso in cui vengono restituiti questi valori. Quindi start viene assegnato a counter. Prima dell'esecuzione del blocco di istruzioni, viene confrontato il valore di counter con quello di end. Se il valore counter è già più grande del valore end (o più piccolo se step è negativo), il ciclo For termina e il controllo passa all'istruzione successiva all'istruzione Next. Atrimenti viene eseguito il blocco di istruzioni.

Ogni volta che Visual Basic incontra l'istruzione Next, incrementa il valore di counter di step e torna all'istruzione For. La variabile counter viene nuovamente confrontata con il valore end e in base al risultato viene eseguito di nuovo il blocco oppure viene effettuata l'uscita dal ciclo. Il processo continua finché counter non passa end oppure non si raggiunge un'istruzione Exit For.

Il ciclo termina solo dopo quando il valore end di counter viene superato. 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, le operazioni di lettura e debug del codice potrebbero risultare più difficili. La modifica del valore start, end o step, invece, non influisce sui valori di iterazione definiti la prima volta che il ciclo è stato eseguito.

Suggerimento

Una struttura Istruzione While...End While (Visual Basic) o Istruzione Do...Loop (Visual Basic) è utile quando si conosce in anticipo il numero di esecuzioni delle istruzioni necessario all'interno del ciclo. Se invece si prevede di eseguire il ciclo per un numero specifico di volte, si consiglia di utilizzare For...Next. Il numero di iterazioni viene definito la prima volta che si entra nel ciclo.

Argomento step

Dal valore di step, che può essere positivo o negativo, dipende il tipo di elaborazione del ciclo come illustrato di seguito:

Se omessa, viene automaticamente impostato il valore 1 per step.

Argomento Counter

Se la variabile counter non è stata dichiarata all'esterno del ciclo, è necessario dichiararla nell'istruzione For. In questo caso, l'ambito di counter è il corpo del ciclo. Non è tuttavia possibile dichiarare counter all'interno e all'esterno del ciclo.

Se lo si desidera, è possibile specificare counter nell'istruzione Next. Ciò consente di migliorare la leggibilità del programma, soprattutto se i cicli For sono annidati. È necessario specificare la stessa variabile presente nell'istruzione For corrispondente.

Il tipo di dati di counter consente di determinare il tipo di iterazione e deve essere incluso tra quelli indicati di seguito:

• Oggetto Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single o Double.

• Enumerazione che viene dichiarata tramite un'Istruzione Enum (Visual Basic).

• Oggetto Object.

• Tipo T che dispone dei seguenti operatori, dove B è un tipo che può essere utilizzato 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

Tramite le espressioni start, end e step è possibile restituire qualsiasi tipo di dati ampliabile al tipo di counter. Se per counter si utilizza un tipo definito dall'utente, potrebbe essere necessario definire l'operatore di conversione CType per convertire i tipi di start, end o step nel tipo di counter.

Cicli annidati

È possibile annidare cicli For inserendo un ciclo all'interno dell'altro. ma dotando ciascuno di essi di una variabile counter univoca.

È inoltre possibile annidare strutture di controllo di tipo diverso inserendole una all'interno dell'altra. Per ulteriori informazioni, vedere Strutture di controllo annidate (Visual Basic).

Se viene rilevata un'istruzione Next di un livello di annidamento esterno prima dell'istruzione Next di un livello interno, il compilatore restituisce un errore. Tuttavia, il compilatore può rilevare questo errore di sovrapposizione solo se si specifica counter in ogni istruzione Next.

Exit For

Mediante l'istruzione Istruzione Exit (Visual Basic) viene eseguita immediatamente l'uscita dal ciclo For…Next e il controllo viene trasferito all'istruzione successiva all'istruzione Next.

È possibile inserire un numero illimitato di istruzioni Exit For in un ciclo For…Next. Se utilizzata all'interno di cicli For…Next annidati, l'istruzione Exit For consente l'uscita dal ciclo più interno e il trasferimento del controllo al livello di annidamento successivo superiore.

L'istruzione Exit For spesso viene utilizzata dopo la valutazione di una determinata condizione, ad esempio in una struttura If...Then...Else. Si potrebbe decidere di utilizzare il controllo Exit For per le seguenti condizioni:

• La continuazione dell'iterazione non è necessaria oppure è impossibile. Tale condizione potrebbe essere causata da un valore erroneo o da una richiesta di terminazione.

• Eccezione intercettata in un blocco Try...Catch...Finally. È possibile utilizzare Exit For alla fine del blocco Finally.

• È presente un ciclo infinito, vale a dire un ciclo che può essere eseguito molte volte oppure all'infinito. Se si rileva una simile condizione, è possibile utilizzare Exit For per interrompere l'esecuzione del ciclo. Per ulteriori informazioni, vedere Istruzione Do...Loop (Visual Basic).

Tramite l'istruzione Continue For il controllo viene trasferito immediatamente alla successiva iterazione del ciclo. Per ulteriori informazioni, vedere Istruzione Continue (Visual Basic).

Esempio

Nell'esempio riportato di seguito viene illustrato l'utilizzo dell'istruzione For…Next. Una variabile di contatore di cicli viene incrementata con ogni singola iterazione del ciclo. L'argomento step non è specificato, pertanto il valore predefinito è impostato su 1.

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

Nell'esempio seguente, gli argomenti counter e step sono numeri a virgola mobile Double.

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 

Nell'esempio seguente vengono illustrate le strutture For...Next annidate con diversi valori di incremento. Il ciclo esterno consente di creare una stringa per ogni iterazione del ciclo. Nel ciclo interno, per ogni iterazione del ciclo viene ridotta una variabile del contatore di cicli.

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

Nell'esempio seguente vengono rimossi tutti gli elementi da un elenco generico. Invece di un'istruzione Istruzione For Each...Next (Visual Basic), viene utilizzata un'istruzione For...Next che consente l'iterazione in ordine decrescente. La ragione sta nel fatto che tramite il metodo removeAt, gli elementi dopo l'elemento rimosso dispongono di 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

Nell'esempio riportato di seguito viene illustrato l'utilizzo 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 And 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

Nell'esempio seguente si scorre un'enumerazione dichiarata utilizzando un'istruzione Istruzione Enum (Visual Basic).

Public Enum Mammals
    Buffalo
    Gazelle
    Mongoose
    Rhinocerous
    Whale
End Enum


Public Sub ListSomeMammals()
    For mammal As Mammals = Mammals.Gazelle To Mammals.Rhinocerous
        Debug.Write(mammal.ToString & " ")
    Next
    Debug.WriteLine("")
    ' Output: Gazelle Mongoose Rhinocerous
End Sub

Nell'esempio seguente, la classe dei parametri dell'istruzione dispone di 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

Vedere anche

Attività

Procedura: migliorare le prestazioni di un ciclo (Visual Basic)

Riferimenti

Istruzione While...End While (Visual Basic)

Istruzione Do...Loop (Visual Basic)

Istruzione Exit (Visual Basic)

Istruzione For Each...Next (Visual Basic)

List<T>

Concetti

Strutture di ciclo (Visual Basic)

Strutture di controllo annidate (Visual Basic)

Cronologia delle modifiche