Instrucción For...Next (Visual Basic)

Repite un grupo de instrucciones un número de veces especificado.

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

Elementos

Ejemplos simples

Utiliza una estructura de For…Next cuando desea repetir un conjunto de instrucciones un número fijo de veces.

En el ejemplo siguiente, la variable de index comienza con un valor de 1 y se incrementa con cada iteración del bucle, finalizando después de que el valor de index cobertura 5.

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

En el ejemplo siguiente, la variable de number comienza en 2 y es baja por 0,25 en cada iteración del bucle, finalizando después de que el valor de number cobertura 0. El argumento de Step de -.25 reduce el valor en 0,25 en cada iteración del bucle.

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 

Bucles anidados

Se pueden anidar bucles For colocando un bucle dentro de otro. En el ejemplo siguiente se muestran estructuras For...Next anidadas con valores de incremento diferentes. El bucle externo crea una cadena para cada iteración del bucle. El bucle interior disminuye una variable de contador de bucle por cada iteración del bucle.

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

Cuando los bucles de anidamiento, cada bucle deben tener una variable única de counter.

También puede anidar distintos tipos de estructuras de control unos dentro de otros. Para obtener más información, vea Estructuras de control anidadas (Visual Basic).

Exit For y Continue For

La instrucción de Exit For inmediatamente sale del bucle de For…Next y transfiere el control a la instrucción que sigue a la instrucción de Next.

la instrucción Continue For transfiere el control inmediatamente a la siguiente iteración del bucle. Para obtener más información, vea Continue (Instrucción, Visual Basic).

En el siguiente ejemplo se muestra el uso de las instrucciones Continue For y Exit For.

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

Puede incluir cualquier número de instrucciones Exit For en un bucle For...Next. Cuando se utiliza dentro de bucles For…Next anidados, Exit For sale del bucle más profundo y transfiere el control al siguiente nivel de anidamiento.

Exit For suele usarse después de que se evalúe alguna condición (por ejemplo, en una estructura de If…Then…Else ). Puede que desee utilizar Exit For para las siguientes condiciones:

• Continuar la iteración es innecesario o imposible. Un valor de error o una solicitud de finalización podría crear esta condición.

• Una instrucción de Try…Catch…Finally detecta una excepción. Puede utilizar Exit For al final del bloque Finally .

• Tiene un bucle infinito, que es un bucle que puede ejecutar un número grande o incluso infinito de veces. Si se detecta este tipo de condición, se puede utilizar Exit For para escapar del bucle. Para obtener más información, vea Instrucción Do...Loop (Visual Basic).

Implementación técnica

Cuando comienza un bucle For...Next, Visual Basic evalúa start end y step. Visual Basic evalúa estos valores únicamente en este momento y después asignará start a counter. Antes de que el bloque de la instrucción se ejecuta, Visual Basic compara counter a end. Si counter ya es mayor que el valor de end (o más pequeño si step es negativo), el bucle de For y el control pasa a la instrucción que sigue a la instrucción de Next. Si no, se ejecuta el bloque de instrucciones.

Cada vez que Visual Basic encuentra la instrucción Next, incrementa counter en el valor indicado en step y vuelve a la instrucción For. Compara de nuevo counter con end y, otra vez, ejecuta el bloque o sale del bucle, según el resultado. Este proceso continúa hasta que counter sobrepasa end o se encuentra una instrucción Exit For.

El bucle no detiene hasta que counter haya pasado end. Si counter es igual a end, el bucle continúa. La comparación que determina si se ejecuta el bloque es counter <= end si step es positivo y counter >= end si step es negativo.

Si cambia el valor de counter mientras dentro de un bucle, el código podría ser más difícil de leer y depuración. Cambie el valor de start, end, o step no afecta a los valores de iteración que se determinados cuando el bucle primero se escribió.

Si se anida bucles, el compilador señala un error si encuentra la instrucción de Next de un nivel de anidamiento externo antes de la instrucción de Next de un nivel interno. Sin embargo, el compilador sólo puede detectar este error superpuesto si se especifica counter en cada instrucción Next.

Step (argumento)

El valor de step puede ser positivo o negativo. Este parámetro determina el procesamiento de bucles según la tabla siguiente:

El valor predeterminado de step es 1.

Argumento de contador

La siguiente tabla se indica si counter define una nueva variable local cuyo ámbito al bucle completo de For…Next. Esta determinación depende de si datatype está presente y si counter está definido.

El tipo de datos de counter determina el tipo de la iteración, que debe ser uno de los tipos siguientes:

• Un Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single, o Double.

• Una enumeración que se declara utilizando una Instrucción Enum (Visual Basic).

• Interfaz Object.

• Un tipo T que tiene los siguientes operadores, donde B es un tipo que puede utilizarse en una expresión 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

Puede especificar opcionalmente la variable de counter en la instrucción de Next. Esta sintaxis mejora la legibilidad del programa, especialmente si ha anidado bucles de For. Debe especificar la variable que aparece en la instrucción correspondiente de For.

Las expresiones start, end y step pueden evaluarse como cualquier tipo de datos que se amplíe al tipo de counter. Si utiliza un tipo definido por el usuario para counter, podría tener que definir el operador de conversión de CType para convertir tipos de start, de end, o de step al tipo de counter.

Ejemplo

El ejemplo siguiente elimina todos los elementos de una lista genérica. En lugar de Instrucción For Each...Next (Visual Basic), el ejemplo muestra una instrucción de For…Next que recorra en orden descendente. El ejemplo utiliza esta técnica porque el método de removeAt hace elementos después del elemento quitado para tener un valor de índice mínimo.

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

El ejemplo siguiente se recorre en iteración una enumeración que se declara mediante Instrucción Enum (Visual Basic).

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

En el siguiente ejemplo, los parámetros de la instrucción utilizan una clase que tiene sobrecargas de operador para los operadores +, -, >= y <=.

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

Vea también

Referencia

Instrucción While...End While (Visual Basic)

Instrucción Do...Loop (Visual Basic)

Exit (Instrucción, Visual Basic)

List

Conceptos

Estructuras de bucles (Visual Basic)

Estructuras de control anidadas (Visual Basic)

Otros recursos

Colecciones (C# y Visual Basic)