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

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

Sintaxe

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

Partes

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 Step argumento de reduz o valor em -.25 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 

Loops de aninhamento

Você pode aninhar For loops colocando um loop dentro do outro. O exemplo a seguir demonstra estruturas ...Next aninhadas Forque 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

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

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

Sair para e continuar para

O Exit For comunicado sai imediatamente do For...Next loop e transfere o controle para a instrução que segue a Next instrução.

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 Continue For instruções and 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 laço. Quando usado dentro de For...Next loops, Exit For sai do loop mais interno e transfere o controle para o próximo nível superior de aninhamento.

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 Fazer... Instrução 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 se counter compara ao end. Se counter já for maior que o end valor (ou menor se step for negativo), o loop termina e o For controle passa para a instrução que segue a Next instrução. Caso contrário, o bloco de instrução será executado.

Cada vez que o Visual Basic encontra a Next instrução, ela aumenta stepcounter e retorna à For instrução. Novamente ele se compara counter ao end, e novamente ele executa o bloco ou sai do loop, dependendo do resultado. Este processo continua até counter que passe end ou uma Exit For declaração seja encontrada.

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

Se você alterar o valor de while dentro de um loop, seu código pode ser mais difícil de counter ler e depurar. Alterar o valor de , endou step não afeta os valores de startiteração que foram determinados quando o loop foi inserido pela primeira vez.

Se você aninhar loops, o compilador sinalizará 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 da etapa

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

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 da sua datatype presença e da sua counter já definição.

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

• A Byte, SByte, UShort, Short, , UInteger, Integer, ULong, DecimalLongSingleou .Double

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

As startexpressões , ende podem step ser avaliadas para qualquer tipo de dados que se amplie 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 por meio de 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
• Enquanto... Declaração Terminar Enquanto
• Faça... Instrução Loop
• Estruturas de controle aninhadas
• Declaração de saída
• Collections