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

Artículo
04/07/2023

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

Sintaxis

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

Partes

Parte	Descripción
`counter`	Obligatorio en la instrucción `For`. Variable numérica. Variable de control para el bucle. Para obtener más información, vea Contraargumento más adelante en este tema.
`datatype`	Opcional. Tipo de datos de `counter`. Para obtener más información, vea Contraargumento más adelante en este tema.
`start`	Obligatorio. Expresión numérica. Valor inicial de `counter`.
`end`	Obligatorio. Expresión numérica. El valor final de `counter`.
`step`	Opcional. Expresión numérica. Cantidad por la que `counter` se incrementa cada vez a través del bucle.
`statements`	Opcional. Una o varias instrucciones entre `For` y `Next` que ejecutan el número de veces especificado.
`Continue For`	Opcional. Transfiere el control a la siguiente iteración del bucle.
`Exit For`	Opcional. Transfiere el control fuera del bucle `For`.
`Next`	Necesario. Termina la definición del bucle `For`.

Nota

La palabra clave To se usa en esta instrucción para especificar el intervalo del contador. También puede usar esta palabra clave en Instrucción Select...Case y en declaraciones de matriz. Para obtener más información sobre las declaraciones de matriz, vea Instrucción Dim.

Ejemplos sencillos

Use una estructura For...Next cuando desee repetir un conjunto de instrucciones un número de veces.

En el ejemplo siguiente, la variable 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 alcance 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 number comienza con un valor de 2 y se reduce por 0.25 con cada iteración del bucle, finalizando después de que el valor de number alcance 0. El argumento Stepde -.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

Sugerencia

Una instrucción While...End While o instrucción Do... Loop funciona bien cuando no se sabe con antelación cuántas veces se ejecutan las instrucciones en el bucle. Sin embargo, cuando se espera ejecutar el bucle un número específico de veces, un bucle For...Next es una mejor opción. El número de iteraciones se determina al entrar por primera vez en el bucle.

Anidamiento de bucles

Puede anidar bucles For si coloca un bucle dentro de otro. En el ejemplo siguiente se muestran estructuras For...Next anidadas que tienen valores de paso diferentes. El bucle externo crea una cadena para cada iteración del bucle. El bucle interno disminuye una variable de contador de bucle para 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

Al anidar bucles, cada bucle debe tener una variable counter única.

También puede anidar diferentes tipos de estructuras de control entre sí. Para obtener más información, vea Estructuras de control anidadas.

Exit For y Continue For

La instrucción Exit For sale inmediatamente de For...Next y transfiere inmediatamente el control a la instrucción que hay después de la instrucción Next.

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

En el ejemplo siguiente 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 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

Puede colocar cualquier número de instrucciones Exit For en un bucle For...Bucle Next. Cuando se usa dentro de For... anidadosCuando se usa dentro de bucles Next anidados, Exit For permite salir del bucle más interno y transfiere el control al siguiente nivel superior de anidamiento.

Exit For a menudo se usa después de una evaluación de alguna condición, por ejemplo, en una estructura If...Then...Else. Es posible que quiera usar Exit For para las condiciones siguientes:

Seguir iterando es innecesario o imposible. Un valor erróneo o una solicitud de finalización podría crear esta condición.
Una instrucción Try...Catch...Finally detecta una excepción. Puede usar Exit For al final del bloque Finally.
Tiene un bucle infinito, que es un bucle que podría ejecutarse un número grande o incluso infinito de veces. Si detecta esta condición, puede usar Exit For para escapar del bucle. Para más información, consulte Do...Loop (Instrucción).

Implementación técnica

Cuando se inicia un bucle For...Next, Visual Basic evalúa start, endy step. Visual Basic evalúa estos valores solo en este momento y, a continuación, asigna start a counter. Antes de que se ejecute el bloque de instrucciones, Visual Basic se compara counter con end. Si counter ya es mayor que el valor end (o menor si step es negativo), el bucle For finaliza y el control pasa a la instrucción que sigue a la instrucción Next. De lo contrario, el bloque de instrucciones se ejecuta.

Cada vez que Visual Basic encuentra la instrucción Next, se incrementa counter por step y vuelve a la instrucción For. De nuevo se compara counter con end y, de nuevo, ejecuta el bloque o sale del bucle, en función del resultado. Este proceso continúa hasta que counter pasa a end o se encuentra una instrucción Exit For.

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

Si cambia el valor de counter mientras está dentro de un bucle, es posible que el código sea más difícil de leer y depurar. Cambiar el valor de start, endo step no afecta a los valores de iteración que se determinaron cuando se especificó el bucle por primera vez.

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

Argumento step

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

Valor step	El bucle se ejecuta si
Positivo o cero	`counter`<= `end`
Negativo	`counter`>= `end`

El valor predeterminado de step es 1.

Contraargumento

En la tabla siguiente se indica si counter define una nueva variable local cuyo ámbito es todo el bucle For…Next. Esta determinación depende de si datatype está presente y de si counter ya está definido.

¿Está `datatype` presente?	¿Se ha definido ya `counter`?	Resultado (si `counter` define una nueva variable local cuyo ámbito es todo el bucle `For...Next`)
No	Sí	No, porque `counter` ya está definido. Si el ámbito de `counter` no es local para el procedimiento, se produce una advertencia en tiempo de compilación.
No	No	Sí. El tipo de datos se deduce de las expresiones `start`, `end` y `step`. Para obtener más información sobre la inferencia de tipos, vea Instrucción Option Infer e Inferencia de tipo de variable local.
Sí	Sí	Sí, pero solo si la variable existente `counter` está definida fuera del procedimiento. Esa variable sigue siendo independiente. Si el ámbito de la variable existente `counter` es local para el procedimiento, se produce un error en tiempo de compilación.
Sí	No	Sí.

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

Un Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single, o Double.
Enumeración que se declara mediante una instrucción Enum.
Una clase Object.
Un tipo T que tiene los operadores siguientes, donde B es un tipo que se puede usar 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

Opcionalmente, puede especificar la variable counter en la instrucción Next. Esto mejora la legibilidad del programa, especialmente si tiene bucles For anidados. Debe especificar la misma variable que la que aparece en la instrucción For correspondiente.

Las expresiones start, end y step pueden evaluarse como cualquier tipo de datos que amplíe al tipo de counter. Si usa un tipo definido por el usuario para counter, es posible que tenga que definir el operador de conversión CType para convertir los tipos de start, endo step al tipo de counter.

Ejemplo 1

El ejemplo siguiente quita todos los elementos de una lista genérica. En lugar de una Instrucción For each...Next, en el ejemplo se muestra una instrucción For...Next que recorre en iteración en orden descendente. En el ejemplo se usa esta técnica porque el método removeAt hace que los elementos después del elemento quitado tengan un valor de índice inferior.

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

Ejemplo 2

En el ejemplo siguiente se recorre en iteración una enumeración declarada mediante una instrucción 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

Ejemplo 3

En el ejemplo siguiente, los parámetros de instrucción usan 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

Compartir a través de