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

Repete um grupo de instruções um número especificado de vezes.Repeats a group of statements a specified number of times.

SintaxeSyntax

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

PartesParts

PartePart DescriçãoDescription
counter Necessário na instrução For.Required in the For statement. Variável numérica.Numeric variable. A variável de controle para o loop.The control variable for the loop. Para obter mais informações, consulte o argumento Counter mais adiante neste tópico.For more information, see Counter Argument later in this topic.
datatype Opcional.Optional. Tipo de dados de counter.Data type of counter. Para obter mais informações, consulte o argumento Counter mais adiante neste tópico.For more information, see Counter Argument later in this topic.
start Necessária.Required. Expressão numérica.Numeric expression. O valor inicial de counter.The initial value of counter.
end Necessária.Required. Expressão numérica.Numeric expression. O valor final de counter.The final value of counter.
step Opcional.Optional. Expressão numérica.Numeric expression. O valor pelo qual counter é incrementado a cada vez pelo loop.The amount by which counter is incremented each time through the loop.
statements Opcional.Optional. Uma ou mais instruções entre For e Next que executam o número especificado de vezes.One or more statements between For and Next that run the specified number of times.
Continue For Opcional.Optional. Transfere o controle para a próxima iteração do loop.Transfers control to the next loop iteration.
Exit For Opcional.Optional. Transfere o controle do loop de For.Transfers control out of the For loop.
Next Necessária.Required. Encerra a definição do loop de For.Terminates the definition of the For loop.

Observação

A palavra-chave To é usada nesta instrução para especificar o intervalo para o contador.The To keyword is used in this statement to specify the range for the counter. Você também pode usar essa palavra-chave na marca de seleção... Instrução Case e em declarações de matriz.You can also use this keyword in the Select...Case Statement and in array declarations. Para obter mais informações sobre declarações de matriz, consulte instrução Dim.For more information about array declarations, see Dim Statement.

Exemplos simplesSimple Examples

Você usa uma estrutura For...Next quando você deseja repetir um conjunto de instruções por um número definido de vezes.You use a For...Next structure when you want to repeat a set of statements a set number of times.

No exemplo a seguir, a variável index começa com um valor de 1 e é incrementada com cada iteração do loop, terminando depois que o valor de index chega a 5.In the following example, the index variable starts with a value of 1 and is incremented with each iteration of the loop, ending after the value of index reaches 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 é reduzida por 0,25 em cada iteração do loop, terminando depois que o valor de number chega a 0.In the following example, the number variable starts at 2 and is reduced by 0.25 on each iteration of the loop, ending after the value of number reaches 0. O argumento Step de -.25 reduz o valor de 0,25 em cada iteração do loop.The Step argument of -.25 reduces the value by 0.25 on each iteration of the 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

Um tempo... Instrução End While ou do... Instrução de loop funciona bem quando você não sabe antecipadamente quantas vezes executar as instruções no loop.A While...End While Statement or Do...Loop Statement works well when you don't know in advance how many times to run the statements in the loop. No entanto, quando você espera executar o loop um número específico de vezes, um loop For...Next é uma opção melhor.However, when you expect to run the loop a specific number of times, a For...Next loop is a better choice. Você determina o número de iterações quando entra o loop pela primeira vez.You determine the number of iterations when you first enter the loop.

Loops de aninhamentoNesting Loops

Você pode aninhar loops de For colocando um loop dentro de outro.You can nest For loops by putting one loop within another. O exemplo a seguir demonstra estruturas For...Next aninhadas que têm valores de etapa diferentes.The following example demonstrates nested For...Next structures that have different step values. O loop externo cria uma cadeia de caracteres para cada iteração do loop.The outer loop creates a string for every iteration of the loop. O loop interno decrementa uma variável de contador de loop para cada iteração do loop.The inner loop decrements a loop counter variable for every iteration of the 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 de counter exclusiva.When nesting loops, each loop must have a unique counter variable.

Você também pode aninhar estruturas de controle de tipos diferentes entre si.You can also nest different kinds control structures within each other. Para obter mais informações, consulte estruturas de controle aninhado.For more information, see Nested Control Structures.

Sair para e continuar paraExit For and Continue For

A instrução Exit For encerra imediatamente o For...NextThe Exit For statement immediately exits the ForNext loop e transfere o controle para a instrução que segue a instrução Next.loop and transfers control to the statement that follows the Next statement.

A instrução Continue For transfere o controle imediatamente para a próxima iteração do loop.The Continue For statement transfers control immediately to the next iteration of the loop. Para obter mais informações, consulte instrução Continue.For more information, see Continue Statement.

O exemplo a seguir ilustra o uso das instruções Continue For e Exit For.The following example illustrates the use of the Continue For and Exit For statements.

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...NextYou can put any number of Exit For statements in a ForNext While.loop. Quando usado dentro de Foraninhados...NextWhen used within nested ForNext loops, Exit For sai do loop mais interno e transfere o controle para o próximo nível mais alto de aninhamento.loops, Exit For exits the innermost loop and transfers control to the next higher level of nesting.

Exit For geralmente é usado depois que você avalia alguma condição (por exemplo, em uma estrutura If...Then...Else).Exit For is often used after you evaluate some condition (for example, in an If...Then...Else structure). Talvez você queira usar Exit For para as seguintes condições:You might want to use Exit For for the following conditions:

  • Continuar a iterar é desnecessário ou impossível.Continuing to iterate is unnecessary or impossible. Um valor errado ou uma solicitação de encerramento pode criar essa condição.An erroneous value or a termination request might create this condition.

  • Uma instrução Try...Catch...Finally captura uma exceção.A Try...Catch...Finally statement catches an exception. Você pode usar Exit For no final do bloco de Finally.You might use Exit For at the end of the Finally block.

  • Você tem um loop infinito, que é um loop que poderia executar um número grande ou mesmo infinito de vezes.You have an endless loop, which is a loop that could run a large or even infinite number of times. Se você detectar essa condição, poderá usar Exit For para escapar do loop.If you detect such a condition, you can use Exit For to escape the loop. Para obter mais informações, consulte do... Instrução loop.For more information, see Do...Loop Statement.

Implementação técnicaTechnical Implementation

Quando um loop de For...Next é iniciado, Visual Basic avalia start, ende step.When a For...Next loop starts, Visual Basic evaluates start, end, and step. Visual Basic avalia esses valores somente no momento e atribui start ao counter.Visual Basic evaluates these values only at this time and then assigns start to counter. Antes de executar o bloco de instrução, Visual Basic compara counter com end.Before the statement block runs, Visual Basic compares counter to end. Se counter já for maior do que o valor de end (ou menor se step for negativo), o loop de For terminará e o controle passará para a instrução que segue a instrução de Next.If counter is already larger than the end value (or smaller if step is negative), the For loop ends and control passes to the statement that follows the Next statement. Caso contrário, o bloco de instrução será executado.Otherwise, the statement block runs.

Cada vez que Visual Basic encontra a instrução Next, ele incrementa counter por step e retorna à instrução For.Each time Visual Basic encounters the Next statement, it increments counter by step and returns to the For statement. Novamente, ele compara counter com ende, novamente, executa o bloco ou sai do loop, dependendo do resultado.Again it compares counter to end, and again it either runs the block or exits the loop, depending on the result. Esse processo continua até que counter passe end ou uma instrução Exit For seja encontrada.This process continues until counter passes end or an Exit For statement is encountered.

O loop não é interrompido até que counter tenha passado end.The loop doesn't stop until counter has passed end. Se counter for igual a end, o loop continuará.If counter is equal to end, the loop continues. A comparação que determina se o bloco será executado counter <= end se step for positiva e counter >= end se step for negativo.The comparison that determines whether to run the block is counter <= end if step is positive and counter >= end if step is negative.

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.If you change the value of counter while inside a loop, your code might be more difficult to read and debug. 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.Changing the value of start, end, or step doesn't affect the iteration values that were determined when the loop was first entered.

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.If you nest loops, the compiler signals an error if it encounters the Next statement of an outer nesting level before the Next statement of an inner level. No entanto, o compilador pode detectar esse erro sobreposto somente se você especificar counter em cada instrução Next.However, the compiler can detect this overlapping error only if you specify counter in every Next statement.

Argumento StepStep Argument

O valor de step pode ser positivo ou negativo.The value of step can be either positive or negative. Esse parâmetro determina o processamento de loop de acordo com a tabela a seguir:This parameter determines loop processing according to the following table:

Valor da etapaStep value O loop é executado seLoop executes if
Positivo ou zeroPositive or zero counter <= end
NegativoNegative counter >= end

O valor padrão de step é 1.The default value of step is 1.

Argumento do contadorCounter Argument

A tabela a seguir indica se counter define uma nova variável local que tem como escopo o loop de For…Next inteiro.The following table indicates whether counter defines a new local variable that’s scoped to the entire For…Next loop. Essa determinação depende de se o datatype está presente e se counter já está definido.This determination depends on whether datatype is present and whether counter is already defined.

datatype está presente?Is datatype present? O counter já está definido?Is counter already defined? Resultado (se counter define uma nova variável local que tem o escopo de todo o loop de For...Next)Result (whether counter defines a new local variable that’s scoped to the entire For...Next loop)
NãoNo SimYes Não, porque counter já está definido.No, because counter is already defined. Se o escopo de counter não for local para o procedimento, ocorrerá um aviso de tempo de compilação.If the scope of counter isn't local to the procedure, a compile-time warning occurs.
NãoNo NãoNo Sim.Yes. O tipo de dados é inferido das expressões start, ende step.The data type is inferred from the start, end, and step expressions. Para obter informações sobre a inferência de tipos, consulte instrução Option Infer e inferência de tipo local.For information about type inference, see Option Infer Statement and Local Type Inference.
SimYes SimYes Sim, mas somente se a variável de counter existente for definida fora do procedimento.Yes, but only if the existing counter variable is defined outside the procedure. Essa variável permanece separada.That variable remains separate. Se o escopo da variável de counter existente for local para o procedimento, ocorrerá um erro em tempo de compilação.If the scope of the existing counter variable is local to the procedure, a compile-time error occurs.
SimYes NãoNo Sim.Yes.

O tipo de dados de counter determina o tipo da iteração, que deve ser um dos seguintes tipos:The data type of counter determines the type of the iteration, which must be one of the following types:

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

  • Uma enumeração que você declara usando uma instrução enum.An enumeration that you declare by using an Enum Statement.

  • Um Object.An Object.

  • Um tipo T que tem os seguintes operadores, em que B é um tipo que pode ser usado em uma expressão Boolean.A type T that has the following operators, where B is a type that can be used in a Boolean expression.

    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 variável counter na instrução Next.You can optionally specify the counter variable in the Next statement. Essa sintaxe melhora a legibilidade do programa, especialmente se você tiver aninhado loops de For.This syntax improves the readability of your program, especially if you have nested For loops. Você deve especificar a variável que aparece na instrução de For correspondente.You must specify the variable that appears in the corresponding For statement.

As expressões start, ende step podem ser avaliadas como qualquer tipo de dados que se expande para o tipo de counter.The start, end, and step expressions can evaluate to any data type that widens to the type of counter. Se você usar um tipo definido pelo usuário para counter, talvez seja necessário definir o operador de conversão de CType para converter os tipos de start, endou step no tipo de counter.If you use a user-defined type for counter, you might have to define the CType conversion operator to convert the types of start, end, or step to the type of counter.

ExemploExample

O exemplo a seguir remove todos os elementos de uma lista genérica.The following example removes all elements from a generic list. Em vez de um para cada... A próxima instrução, o exemplo mostra uma instrução For...Next que itera em ordem decrescente.Instead of a For Each...Next Statement, the example shows a For...Next statement that iterates in descending order. O exemplo usa essa técnica porque o método removeAt faz com que elementos depois do elemento removido tenham um valor de índice inferior.The example uses this technique because the removeAt method causes elements after the removed element to have a lower index value.

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

ExemploExample

O exemplo a seguir itera através de uma enumeração que é declarada usando uma instrução enum.The following example iterates through an enumeration that's declared by using an 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

ExemploExample

No exemplo a seguir, os parâmetros de instrução usam uma classe que tem sobrecargas de operador para os operadores +, -, >=e <=.In the following example, the statement parameters use a class that has operator overloads for the +, -, >=, and <= operators.

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émSee also