Para...Próxima Declaração (Visual Basic)

Repete um grupo de instruções enquanto o contador de loop se aproxima de seu valor final.

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 Counter Argument mais adiante neste tópico.
datatype	Opcional. Tipo de dados de counter. Para obter mais informações, consulte Counter Argument mais adiante neste tópico.
start	Obrigatório Expressão numérica. O valor inicial de counter.
end	Obrigatório 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 For loop.
Next	Obrigatório Encerra a definição do For loop.

Observação

A To palavra-chave é 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 declarações de matriz, consulte Dim Statement.

Exemplos simples

Você usa uma Forestrutura ...Next quando deseja repetir um conjunto de instruções um número definido de vezes.

No exemplo a seguir, a index variável 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 number variável começa em 2 e é reduzida em 0,25 em cada iteração do loop, terminando após o valor de number atingir 0. O Step argumento de -.25 reduz 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 Forloop ...Next é uma opção melhor. Você determina o número de iterações quando insere 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 Exit For declaração encerra imediatamente o For... Next e transfere o controle para a instrução que segue a instrução Next.

A Continue For instrução transfere o controle imediatamente para a próxima iteração do loop. Para obter mais informações, consulte Declaraçã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 laço. Quando usado no For… aninhado Next 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 depois de avaliar alguma condição (por exemplo, em um If...Then...Else estrutura). 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.

• A Try...Catch...Finally instrução captura uma exceção. Você pode usar Exit For no final do Finally bloco.

• Você tem um loop sem fim, que é um loop que pode executar um número grande ou até infinito de vezes. Se você detectar tal condição, poderá usar Exit For para escapar do loop. Para obter mais informações, consulte Do...Loop Statement.

Implementação técnica

Quando um Forloop ...Next é iniciado, o Visual Basic avalia start, ende step. O Visual Basic avalia esses valores apenas neste momento e, em seguida, atribui start a counter. Antes de executar o bloco de instrução, o Visual Basic compara counter com 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, ele incrementa counter por step e retorna à instrução For. Novamente, compara-se counter a end e, mais uma vez, 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 por end. Se counter é igual a end, o loop continua. 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 você alterar o valor de counter enquanto estiver dentro de um loop, seu código poderá ser mais difícil de ler e depurar. Alterar o valor de start, endou 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 poderá detectar esse erro de sobreposição somente se você especificar counter em cada Next instrução.

Argumento de etapa

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

Valor do passo	O loop será executado se
Positivo ou zero	counter <= end
Negativo	counter >= end

O valor step padrão é 1.

Contra-argumento

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

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

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

• A Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single ou Double.

• Uma enumeração que você declara usando uma declaraçã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, você pode especificar a counter variável na Next instrução. Essasintaxe melhora a legibilidade do programa, especialmente se você tiver loops For aninhados. Você deve especificar a variável que aparece na instrução correspondente For .

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, counter, talvez seja necessário definir o operador de conversão CType para converter os tipos de start, end ou step para o tipo de counter.

Exemplo 1

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

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 que tem sobrecargas de operador para os 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

Consulte também

• List<T>
• Estruturas de Loop
• Instrução While...End While
• Instrução Do...Loop
• Estruturas de Controle Aninhadas
• Instrução Exit
• Coleções