Istruzione For...Next (Visual Basic)

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

Parte Descrizione
counter Obbligatorio nell'istruzione For . Variabile numerica. Variabile di controllo per il ciclo. Per altre informazioni, vedere Argomento contatore più avanti in questo argomento.
datatype facoltativo. Tipo di dati di counter. Per altre informazioni, vedere Argomento contatore 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 si attraversa il ciclo.
statements facoltativo. Una o più istruzioni tra For e Next che eseguono il numero di volte specificato.
Continue For facoltativo. Trasferisce il controllo all'iterazione del ciclo successivo.
Exit For facoltativo. Trasferisce il controllo fuori dal For ciclo.
Next Obbligatorio. Termina la definizione del For ciclo.

Nota

La To parola chiave viene usata in questa istruzione per specificare l'intervallo per il contatore. È anche possibile usare questa parola chiave in Select... Istruzione case e dichiarazioni di matrice. Per altre informazioni sulle dichiarazioni di matrice, vedere Istruzione Dim.

Semplici esempi

Si usa una Forstruttura ...Next quando si vuole ripetere un set di istruzioni un numero di volte impostato.

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 a 2 e viene ridotta di 0,25 su ogni iterazione del ciclo, terminando dopo il valore di number raggiunge 0. L'argomento Step di -.25 riduce il valore di 0,25 in 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 po' ... Fine dell'istruzione odo... Loop Istruzione funziona correttamente quando non si conosce 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 il ciclo.

Cicli di annidamento

È possibile annidare For i cicli inserendo un ciclo all'interno di un altro. Nell'esempio seguente vengono illustrate 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 annidare 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 per e continua per

L'istruzione Exit For chiude immediatamente il For...Next ciclo 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 continua.

Nell'esempio seguente viene illustrato l'uso delle Continue For istruzioni 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 qualsiasi numero di Exit For istruzioni in un For...Next Ciclo. Quando usato all'interno di annidati For...Next cicli, Exit For chiude il ciclo più interno e trasferisce il controllo al successivo livello superiore 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 eseguire l'iterazione non è necessaria o impossibile. Un valore errato o una richiesta di terminazione potrebbe creare questa condizione.

  • A Try...Catch ...Finally l'istruzione rileva un'eccezione. È possibile usare Exit For alla fine del Finally blocco.

  • Si dispone di un ciclo infinito, ovvero un ciclo che potrebbe eseguire un numero elevato o anche 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 Fare... istruzione Loop.

Implementazione tecnica

Quando viene avviato 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, il blocco di istruzioni viene eseguito.

Ogni volta che Visual Basic incontra l'istruzione, counter aumenta e restituisce all'istruzione NextFor.step counter Di nuovo confronta con end, e di nuovo esegue il blocco o chiude il ciclo, a seconda del risultato. Questo processo continua fino a quando non viene end superata o rilevata counter un'istruzioneExit For.

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

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

Se si annidano 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 Next istruzione.

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 Loop viene eseguito se
Positivo o zero counter<= end
Negativo 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 For…Next ciclo. Questa determinazione dipende dal fatto che datatype sia presente e se 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 No, perché counter è già definito. Se l'ambito di counter non è locale alla procedura, si verifica un avviso in fase di compilazione.
No No Sì. Il tipo di dati viene dedotto dalle startespressioni , ende step . Per informazioni sull'inferenza dei tipi, vedere Istruzione Inferenza opzione e Inferenza tipo locale.
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 alla routine, si verifica un errore in fase di compilazione.
No Sì.

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

  • ShortUShortULongUIntegerSByteLongDecimalIntegerOggetto Byte, , Singleo .Double

  • Enumerazione dichiarata tramite un'istruzione Enum.

  • Oggetto Object.

  • Tipo con gli operatori seguenti, dove B è un tipo T che può essere usato in un'espressioneBoolean.

    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 si hanno cicli annidati For . È necessario specificare la variabile visualizzata nell'istruzione corrispondente For .

Le startespressioni , ende step possono valutare qualsiasi tipo di dati che si estende al tipo di counter. Se si usa un tipo definito dall'utente per , potrebbe essere necessario definire l'operatore di conversione per counterconvertire i tipi di start, endo step nel tipo di counter.CType

Esempio 1

Nell'esempio seguente vengono rimossi tutti gli elementi da un elenco generico. Invece di un oggetto For Each... Istruzione successiva, l'esempio mostra un'istruzione For...Next che esegue l'iterazione in ordine decrescente. Nell'esempio viene usata questa tecnica perché il removeAt metodo causa l'esecuzione degli elementi dopo l'elemento rimosso per avere 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

L'esempio seguente esegue l'iterazione tramite 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

Vedi anche