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

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

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

Parts

Observação
O To palavra-chave é usada aqui para especificar o intervalo para o contador. Ele também é usado para especificar um intervalo de valores de Declaração Select...Case (Visual Basic) e nas declarações de matriz. Para obter mais informações sobre declarações de matriz, consulte Instrução Dim (Visual Basic).

Comentários

Use a For...Next estrutura quando você deseja repetir um conjunto de instruções um número definido de vezes.

When a For...Next loop começa, avalia a Visual Basic start, end, e step. Este é o único momento em que ele avalia esses valores. Em seguida, atribui start para counter. Antes da execução do bloco de demonstrativo , ele compara counter para end. Se counter já é maior do que o end valor (ou menor se step for negativo), o For loop é encerrado e controle passa a seguinte demonstrativo de Next demonstrativo. Caso contrário, o bloco de demonstrativo é executada.

Sempre que encontrar em Visual Basic a Next demonstrativo, incrementa counter por step e retorna para o For demonstrativo. Novamente compara counter para end, e novamente ele executa o bloco ou sai do loop, dependendo do resultado. Esse processo continua até counter passa end ou um Exit For demonstrativo é encontrado.

O loop não pára até counter passou end. Se counter é igual a end, o loop continua. A comparação que determina se deve executar o bloco for counter < = end se step é positiva e counter > = end se step é negativo.

Alterar o valor de counter enquanto dentro um loop pode tornar mais difícil para leitura e depurar seu código. Alterar o valor de start, end, ou step não afeta os valores de iteração determinados quando o loop foi inserido pela primeira vez.

Argumento de etapa

O valor de step pode ser positivo ou negativo. Ele determina que o loop de processamento da seguinte maneira:

Se não for especificado, step o padrão é 1.

Contador Argumento

Se counter não foi declarada fora desse loop, você precisa declará-la na For demonstrativo. Neste caso, o escopo da counter é o corpo do loop. No entanto, você não pode declarar counter tanto fora como dentro do loop.

Opcionalmente, você pode especificar counter na Next demonstrativo. Isso melhora a legibilidade do seu programa, especialmente se você tiver aninhado For loops. Você deve especificar a mesma variável como aquela que aparece no correspondente For demonstrativo.

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

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

• Uma enumeração declare usando um Declaração Enum (Visual Basic).

• An Object.

• Um tipo de T que tem os seguintes operadores, onde B é um tipo que pode ser usado em um 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

O start, end, e step expressões podem avaliar a qualquer tipo de dados que amplia o tipo de counter. Se você usar um usuário-definição de tipo para counter, isso significa que talvez você precise definir o CType operador de conversão para converter os tipos de start, end, ou step o tipo de counter.

O aninhamento de Loops

Você pode aninhar For loops colocando um loop dentro de outro. No entanto, cada loop deve ter um único counter variável.

Você também pode aninhar diferentes tipos de estruturas de controle entre si. For more information, see Estruturas de controle aninhado (Visual Basic).

Se um Nextademonstrativo de um nível de aninhamento externa é encontrado antes do Next de um nível interno, o compilador sinaliza um erro. No entanto, o compilador pode detectar isso sobreposição de erro somente se você especificar counter em cada Next demonstrativo.

Sair para

O Declaração Saída (Visual Basic) imediatamente sai do For…Nextcontrolam deloop e transferências, a seguinte demonstrativo de Nextdemonstrativo.

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

Exit Forgeralmente é usado depois de avaliar algumas condições, por exemplo em um If...Then...Else estrutura. Talvez você queira usar Exit For para as seguintes condições:

• Continuando a iterar é desnecessária ou impossível. Isso pode ser causado por um valor errado ou uma solicitaçãode encerramento.

• Uma exceção é detectada em um Try...Catch...Finally. Você pode usar Exit For no final de Finally bloco.

• Há um infinito loop, que é um loop que poderia executar um número grande ou até mesmo infinito de vezes. If you detect such a condition, you can use Exit For to escape the loop. For more information, see Declaração Do...Loop (Visual Basic).

O Continue Fordedemonstrativo transfere o controle imediatamente para a próxima iteração do loop. For more information, see Declaração Continue (Visual Basic).

Exemplo

O exemplo a seguir ilustra o uso de For…Next demonstrativo. Uma variável de contador de loop é incrementado a cada iteração do loop. O step argumento não for especificado, portanto, o padrão é 1.

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

No exemplo a seguir, o counter e step argumentos são Double ponto flutuante números.

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 

O exemplo a seguir demonstra aninhadas For...Next estruturas que possuem valores de etapa diferente. O loop externo cria uma seqüência de caracteres para cada iteração do loop. Decrementa a loop de interno um loop contador variável 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

O exemplo a seguir remove todos os elementos de uma lista genérica. Instead of a Instrução For Each...Next (Visual Basic), a For...Nexté usado ademonstrativo que itera em ordem decrescente. Isso ocorre porque o removeAt método faz com que elementos após o elemento removido para que 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

O exemplo a seguir ilustra o uso de Continue For e Exit For instruções.

For index As Integer = 1 To 100000
    ' If index is between 5 and 7, continue
    ' with the next iteration.
    If index >= 5 And 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

O exemplo a seguir itera por meio de uma enumeração declarada usando um Declaração Enum (Visual Basic).

Public Enum Mammals
    Buffalo
    Gazelle
    Mongoose
    Rhinocerous
    Whale
End Enum


Public Sub ListSomeMammals()
    For mammal As Mammals = Mammals.Gazelle To Mammals.Rhinocerous
        Debug.Write(mammal.ToString & " ")
    Next
    Debug.WriteLine("")
    ' Output: Gazelle Mongoose Rhinocerous
End Sub

No exemplo a seguir, os parâmetros da demonstrativo usam uma classe que tenha sobrecargas de operador para o +, -, >=, e <= operadores.

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

Tarefas

Como: Melhorar o desempenho de um loop (Visual Basic)

Referência

Instrução While...End While (Visual Basic)

Declaração Do...Loop (Visual Basic)

Declaração Saída (Visual Basic)

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

List<T>

Conceitos

Estruturas de loop (Visual Basic)

Estruturas de controle aninhado (Visual Basic)

Histórico de alterações