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 For declaração. Variável numérica. A variável de controle para o loop. Para obter mais informações, consulte Counter Argument posteriormente neste tópico.
datatype	Opcional. Tipo de dados de counter. Para obter mais informações, consulte Counter Argument posteriormente 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. A quantidade pela qual counter é incrementada cada vez através 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 esta palavra-chave na declaraçã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 determinado número de vezes.

No exemplo a seguir, a index variável começa com um valor de 1 e é incrementada a cada iteração do loop, terminando após o valor de index atinge 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 atinge 0. O argumento Step de -.25 reduz o valor em 0,25 a cada iteração do 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 

Sugestão

Instrução Enquanto...Fim Enquanto ou Instrução Faça...Loop funciona bem quando não se sabe com antecedência quantas vezes executar as instruções no loop. No entanto, quando você espera executar o loop um número específico de vezes, um Forloop ...Next é uma escolha melhor. Você determina o número de iterações quando entra no loop pela primeira vez.

Loops de aninhamento

Você pode aninhar For ciclos colocando um ciclo dentro do outro. O exemplo a seguir demonstra estruturas For...Next aninhadas que têm valores de etapa diferentes. O loop externo cria uma cadeia de caracteres para cada iteração do loop. O loop interno diminui 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

No aninhamento de ciclos, cada ciclo deve ter uma variável exclusiva counter.

Você também pode aninhar diferentes tipos de estruturas de controlo umas dentro das outras. Para obter mais informações, consulte Estruturas de controle aninhadas.

Sair de 'For' e Continuar no 'For'

O Exit For comunicado sai imediatamente do For... Next loop e transfere o controlo para a instrução que vem após 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 de continuação.

O exemplo a seguir ilustra o uso das declaraçõ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 Exit For declarações em um For... Next ciclo. Quando usado dentro de For... Next loops, Exit For sai do loop mais interno e transfere o controle para o nível de aninhamento superior.

Exit For é frequentemente usado depois de avaliar alguma condição (por exemplo, em um If...Then...Else estrutura). Você pode querer usar Exit For para as seguintes condições:

• Continuar a iterar é desnecessário ou impossível. Um valor incorreto ou uma solicitação de rescisão podem criar essa condição.

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

• Você tem um loop infinito, que é um loop que pode ser executado um grande ou até infinito número de vezes. Se você detetar tal condição, você pode usar Exit For para escapar do loop. Para obter mais informações, consulte Instrução Do...Loop.

Implementação Técnica

Quando um Forloop ...Next é iniciado, o Visual Basic avalia start, ende step. Visual Basic avalia esses valores somente neste momento e, em seguida, atribui start a counter. Antes da execução do bloco de instruções, o Visual Basic compara counter com end. Se counter já for maior que end (ou menor se step for negativo), o loop termina e o controlo passa para a instrução que segue a For. Caso contrário, o bloco de instrução será executado.

Sempre que o Visual Basic encontra a Next declaração, aumenta counter em step e retorna à For declaração. Mais uma vez, compara-se counter a end, e novamente o bloco é executado ou o loop é terminado, dependendo do resultado. Este processo continua até que counter passe por end ou seja encontrada uma instrução Exit For.

O loop não para até counter ter passado end. Se counter for igual a end, o ciclo continua. A comparação que determina se o bloco deve ser executado é counter<= end se step é positivo e counter>= end se step é negativo.

Se alterar o valor de counter enquanto dentro de um loop, o seu código pode ser mais difícil de ler e depurar. Alterar o 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 aninhar ciclos, o compilador sinaliza um erro se encontrar a Next instrução de um nível de aninhamento externo antes da Next instrução de um nível interno. No entanto, o compilador pode detetar esse erro de sobreposição somente se você especificar counter em cada Next instrução.

Argumento do passo

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

Valor da etapa	O loop é 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 For…Next o loop. Esta determinação depende se datatype está presente e se counter já está definido.

Está datatype presente?	Já está counter definido?	Resultado (se counter define uma nova variável local cujo 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 em tempo de compilação.
Não	Não	Yes. O tipo de dados é inferido a partir das expressões start, end e step. Para obter informações sobre inferência de tipo, consulte Instrução de inferência de opção e Inferência de tipo local.
Yes	Yes	Sim, mas apenas 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 em tempo de compilação.
Yes	Não	Yes.

O tipo de dados de counter determina o tipo da 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 se declara utilizando uma declaração Enum.

• Um Object.

• Um tipo T que tem os seguintes operadores, onde B é um tipo que pode ser usado em uma Boolean expressão.

  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, pode especificar a variável counter na declaração Next. Essa sintaxe melhora a legibilidade do teu programa, especialmente se tiveres ciclos aninhados For. 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 dado que se expanda para o tipo de counter. Se você usar um tipo definido pelo usuário para counter, talvez seja necessário definir o CType operador de conversão para converter os tipos de start, endou 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 para cada um... Next Statement, o exemplo mostra uma Forinstrução ...Next 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 através de uma enumeração declarada usando uma Enum Statement.

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 da 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

Ver também

• List<T>
• Estruturas de ciclo
• Enquanto... Declaração Terminar Enquanto
• Faça... Instrução Loop
• Estruturas de controle aninhadas
• Declaração de saída
• Coleções