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

Repite un grupo de instrucciones mientras el contador de bucles se aproxima a su valor final.

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 del bucle. Para obtener más información, vea Counter Argument más adelante en este tema.
`datatype`	Opcional. Tipo de datos de `counter`. Para obtener más información, vea Counter Argument más adelante en este tema.
`start`	Obligatorio. Expresión numérica. Valor inicial de `counter`.
`end`	Obligatorio. Expresión numérica. 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 `For` bucle.
`Next`	Obligatorio. Finaliza la definición del `For` bucle.

Nota:

La To palabra clave 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 Dim Statement.

Ejemplos sencillos

Usas una Forestructura ...Next cuando quieras repetir un conjunto de instrucciones un número de veces.

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

Sugerencia

Un While... End While o Do... Loop es útil cuando no se sabe con antelación cuántas veces se ejecutarán las instrucciones en el bucle. Sin embargo, cuando se espera ejecutar el bucle un número específico de veces, un Forbucle ...Next es una mejor opción. Usted determina el número de iteraciones cuando entra en el bucle por primera vez.

Anidamiento de bucles

Puede anidar bucles For si coloca un bucle dentro de otro. En el ejemplo siguiente se muestran las estructuras anidadas For...Next 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 única counter .

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 Continue For instrucción transfiere el control inmediatamente a la siguiente iteración del bucle. Para obtener más información, vea Continue Statement.

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 una estructura anidada For... Cuando 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 evaluar alguna condición (por ejemplo, en un If...Then...Else estructura). 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 Try...Catch...Finally instrucción captura una excepción. Puede usar Exit For al final del Finally bloque.
Hay 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 el bucle. Para más información, consulte Do...Loop (Instrucción).

Implementación técnica

Cuando se inicia un Forbucle ...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 compara counter con end. Si counter ya es mayor que el valor end (o menor si step es negativo), el bucle For finaliza y control pasa a la instrucción posterior a Next. De lo contrario, el bloque de instrucciones se ejecuta.

Cada vez que Visual Basic encuentra una declaración Next, incrementa counter por step y vuelve a la declaración For. De nuevo se compara counter con endy, 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 haya pasado end. Si counter es igual a end, el bucle continúa. Comparación que determina si se va a 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 su 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 superpuesto si especifica counter en cada Next instrucción.

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`
Negativa	`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 For…Next el bucle. Esta determinación depende de si datatype está presente y si counter ya está definida.

¿Está `datatype` presente?	¿Ya está `counter` definido?	Resultado (si `counter` define una nueva variable local cuyo ámbito comprende 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 `start`expresiones , `end`y `step` . Para obtener información sobre la inferencia de tipos, vea Option Infer Statement y Local Type Inference.
Sí	Sí	Sí, pero solo si la variable existente `counter` se define fuera del procedimiento. Esa variable permanece separada. 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.
Una enumeración que se declara mediante la instrucción Enum.
Un Object.
Tipo T que tiene los operadores siguientes, donde B es un tipo que se puede usar en una Boolean expresión.

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 counter variable en la Next instrucción . Esta sintaxis mejora la legibilidad del programa, especialmente si tiene bucles anidados For . Debe especificar la variable que aparece en la instrucción correspondiente For .

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 CType operador de conversión para convertir los tipos de start, endo step al tipo de counter.

Ejemplo 1

En el ejemplo siguiente se quitan 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 hace que los removeAt 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 utilizan una clase que tiene sobrecargas 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

Consulte también

Comentarios

¿Le resultó útil esta página?

Last updated on 2025-07-22