Istruzione For...Next (Visual Basic)

Articolo
06/08/2023

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`	Facoltativa. 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`	Facoltativa. Espressione numerica. Quantità in base alla quale `counter` viene incrementata ogni volta che si passa attraverso il ciclo.
`statements`	Facoltativa. Una o più istruzioni tra `For` e `Next` che eseguono il numero specificato di volte.
`Continue For`	Facoltativa. Trasferisce il controllo all'iterazione del ciclo successivo.
`Exit For`	Facoltativa. Trasferisce il controllo fuori dal `For` ciclo.
`Next`	Obbligatorio. Termina la definizione del `For` ciclo.

Nota

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

Esempi semplici

Si usa una Forstruttura ...Next quando si desidera 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 da 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 po' di tempo... Istruzione End While o Do... L'istruzione 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 ForconNext 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 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 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 un numero qualsiasi di Exit For istruzioni in un For...Next Ciclo. Se usato all'interno di annidati 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 alcune condizioni (ad esempio, in un If...Then ...Else struttura). È possibile usare Exit For per le condizioni seguenti:

Continuare a eseguire l'iterazione non è necessario 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 può essere eseguito un numero elevato o persino infinito di volte. Se si rileva una condizione di questo tipo, è possibile usare per eseguire Exit For l'escape del ciclo. Per altre informazioni, vedere Do... Istruzione 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 counterstep e restituisce all'istruzione For . Anche in questo caso viene confrontato counter con ende viene eseguito di nuovo il blocco o viene chiuso il ciclo, a seconda del risultato. Questo processo continua fino a quando counter non viene superata end o rilevata un'istruzione Exit For .

Il ciclo non si arresta finché counter non viene superato end. Se counter è uguale a end, il ciclo continua. 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 , endo step non influisce sui valori di startiterazione determinati quando è stato immesso per la prima volta il ciclo.

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 step

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`
Negativo	`counter`>= `end`

Il valore predefinito di step è 1.

Argomento Counter

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	Sì	No, perché `counter` è già definito. Se l'ambito di `counter` non è locale per la routine, viene generato 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 del tipo, vedere Option Infer Statement e Local Type Inference.
Sì	Sì	Sì, ma solo se la variabile esistente `counter` è definita all'esterno della routine. 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, ShortUInteger, Integer, ULong, Long, Decimal, , Singleo 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 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 startespressioni , ende 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 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 For Each... Istruzione successiva, 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 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 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 dell'operatore 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