Instrução For...Next (Visual Basic)

Artigo
04/07/2023

Repete um grupo de instruções por um determinado número de vezes.

Sintaxe

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

Partes

Parte	Descrição
`counter`	Obrigatório na instrução `For`. Variável numérica. A variável de controle para o loop. Para obter mais informações, consulte Contra-argumento posteriormente neste tópico.
`datatype`	Opcional. Tipo de dados de `counter`. Para obter mais informações, consulte Contra-argumento posteriormente neste tópico.
`start`	Obrigatórios. Expressão numérica. O valor inicial de `counter`.
`end`	Obrigatórios. Expressão numérica. O valor final de `counter`.
`step`	Opcional. Expressão numérica. O valor pelo qual `counter` é incrementado cada vez por meio do loop.
`statements`	Opcional. Uma ou mais instruções entre `For` e `Next` que executam o número especificado de vezes.
`Continue For`	Opcional. Transfere o controle para a próxima iteração de loop.
`Exit For`	Opcional. Transfere o controle para fora do loop `For`.
`Next`	Obrigatórios. Finaliza a definição do loop `For`.

Observação

A palavra-chave To é usada nesta instrução para especificar o intervalo para o contador. Você também pode usar essa palavra-chave na Instrução Select...Case e em declarações de matriz. Para obter mais informações sobre as declarações de matriz, consulte Instrução Dim.

Exemplos simples

A estrutura For...Next é usada para repetir um conjunto de instruções por um número definido de vezes.

No exemplo a seguir, a variável index começa com um valor de 1 e é incrementada com cada iteração do loop, terminando após o valor de index atingir 5.

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

No exemplo a seguir, a variável number começa em 2 e diminui 0,25 a cada iteração do loop, terminando após o valor de number atingir 0. O argumento Step de -.25 reduzir o valor em 0,25 em cada iteração do loop.

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

Dica

Uma Instrução While...End While ou Do...Loop funciona bem quando você não sabe com antecedência quantas vezes as instruções devem ser executadas no loop. No entanto, quando você espera executar o loop um número específico de vezes, um loop For...Next é uma opção melhor. Você determina o número de iterações ao inserir o loop pela primeira vez.

Loops de aninhamento

Você pode aninhar loops For colocando um loop dentro de outro. O exemplo a seguir demonstra estruturas aninhadas For...Next que têm valores de etapa diferentes. O loop externo cria uma cadeia de caracteres para cada iteração do loop. O loop interno decrementa uma variável de contador de loop para cada iteração do loop.

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

Ao aninhar loops, cada loop deve ter uma variável counter exclusiva.

Você também pode aninhar diferentes tipos de estruturas de controle entre si. Para obter mais informações, confira Estruturas de controle aninhadas.

Exit For e Continue For

A instrução Exit For sai imediatamente do For…Next e transfere o controle para a instrução que segue a instrução Next.

A instruçãoContinue For transfere o controle imediatamente para a próxima iteração do loop. Para obter mais informações, confira Instrução Continue.

O exemplo a seguir ilustra o uso das instruções 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

Você pode colocar qualquer número de instruções Exit For em um For…Next loop. Quando usado no For… aninhadoNext loops, Exit For sai do loop mais interno e transfere o controle para o próximo nível mais alto de aninhamento.

Exit For geralmente é usado após avaliação de alguma condição (por exemplo, em uma estrutura If...Then...Else). Talvez você queira usar Exit For para as seguintes condições:

Continuar a iterar é desnecessário ou impossível. Um valor incorreto ou uma solicitação de encerramento pode criar essa condição.
Uma instrução Try...Catch...Finally captura uma exceção. Você pode usar Exit For no final do bloco Finally.
Você tem um loop infinito, que é um loop que pode se executado várias vezes ou até infinitamente. Se você detectar essa condição, poderá usar Exit For para pular o loop. Para obter mais informações, confira Instrução Do...Loop.

Implementação Técnica

Quando um loop For...Next é iniciado, o Visual Basic avalia start, end e step. O Visual Basic avalia esses valores apenas neste momento e, em seguida, atribui start a counter. Antes que o bloco de instruções seja executado, o Visual Basic compara counter a end. Se counter já for maior que o valor end (ou menor se step for negativo), o loop For terminará e o controle passará para a instrução que segue a instrução Next. Caso contrário, o bloco de instruções será executado.

Sempre que o Visual Basic encontra a instrução Next, counteré incrementado em step e retorna à instrução For. Novamente, ele compara counter a end e executa o bloco ou sai do loop, dependendo do resultado. Esse processo continua até que counter passe end ou uma instrução Exit For seja encontrada.

O loop não para até que counter tenha passado end. Se counter for igual a end, o loop continuará. A comparação determina se a execução do bloco deve ser counter<= end se step for positivo e counter>= end se step for negativo.

Se o valor de counter for alterado enquanto estiver dentro de um loop, poderá ser mais difícil gravar e depurar o código. A alteração do valor de start, end ou step não afeta os valores de iteração que foram determinados quando o loop foi inserido pela primeira vez.

Se você aninhar loops, o compilador sinalizará um erro se encontrar a instrução Next de um nível de aninhamento externo antes da instrução Next de um nível interno. No entanto, o compilador só poderá detectar esse erro sobreposto se você especificar counter em cada instrução Next.

Argumento de etapa

O valor de step pode ser positivo ou negativo. Esse parâmetro determina o processamento de loop de acordo com a tabela a seguir:

Valor da etapa	O loop será executado se
Positivo ou zero	`counter`<= `end`
Negativo	`counter`>= `end`

O valor padrão de step é 1.

Contra-argumento

A tabela a seguir indica se counter define uma nova variável local com escopo para todo o loop For…Next. Essa determinação depende se datatype está presente e se counter já foi definido.

`datatype` está presente?	`counter` está definido?	Resultado (se `counter` define uma nova variável local com escopo para todo o loop `For...Next`)
No	Sim	Não, porque `counter` já está definido. Se o escopo de `counter` não for local para o procedimento, ocorrerá um aviso de tempo de compilação.
No	Não	Sim. O tipo de dados é inferido das expressões e `start`, `end` e `step`. Para obter informações sobre inferência de tipos, consulte Instrução Option Infer e Inferência de Tipo de Variável Local.
Sim	Sim	Sim, mas somente se a variável `counter` existente for definida fora do procedimento. Essa variável permanece separada. Se o escopo da variável `counter` existente for local para o procedimento, ocorrerá um erro em tempo de compilação.
Sim	Não	Sim.

O tipo de dados de counter determina o tipo de iteração, que deve ser um dos seguintes:

A Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single ou Double.
Uma enumeração declarada usando uma Instrução Enum.
Um Object.
Um tipo T que tem os operadores a seguir, onde B é um tipo que pode ser usado em uma expressão 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

Opcionalmente, é possível especificar a variável counter na instrução Next. Essasintaxe melhora a legibilidade do programa, especialmente se você tiver loops For aninhados. Você precisa especificar a variável exibida na instrução For correspondente.

As expressões start, end e step podem ser avaliadas para qualquer tipo de dados expandido para o tipo de counter. Se você usar um tipo definido pelo usuário para counter, talvez seja necessário definir o operador de conversão CType para converter os tipos start, end ou step para o tipo counter.

Exemplo 1

O exemplo a seguir remove todos os elementos de uma lista genérica. Em vez de uma Instrução For Each...Next, o exemplo mostra uma instrução For...Next que itera em ordem decrescente. O exemplo usa essa técnica porque o método removeAt faz com que os elementos após o elemento removido tenham um valor de índice menor.

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

Exemplo 2

O exemplo a seguir itera por uma enumeração declarada usando uma Instrução 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

Exemplo 3

No exemplo a seguir, os parâmetros de instrução usam uma classe com sobrecargas de operador para operadores +, -, >= 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