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

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

Ejemplos sencillos

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

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

Anidamiento de bucles

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

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

Salir de y continuar para

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

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

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

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 Exit For instrucciones en un For ...Next bucle Cuando se usa en nested For ...Next bucles, Exit For sale 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 structure). Es posible que quiera usar Exit For para las condiciones siguientes:

• Seguir iterar es innecesario o imposible. Un valor erróneo o una solicitud de finalización podrían crear esta condición.

• Un Try ... Catch ...Finally la instrucción detecta una excepción. Puede usar Exit For al final del Finally bloque.

• Tiene un bucle sin fin, que es un bucle que podría ejecutar un número grande o incluso infinito de veces. Si detecta este tipo de condición, puede usar para Exit For escapar el bucle. Para obtener más información, vea Do... Instrucción de bucle.

Implementación técnica

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

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

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

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

Si anida bucles, el compilador señala un error si encuentra la instrucción de un nivel de anidamiento externo antes de la instrucción Next Next de un nivel interno. Sin embargo, el compilador puede detectar este error superpuesto solo si se 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:

El valor predeterminado de step es 1.

Argumento counter

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

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

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

• Enumeración que se declara mediante una instrucción Enum.

• Una clase Object.

• Tipo que T tiene los operadores siguientes, donde es un B 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 instrucción Next . Esta sintaxis mejora la legibilidad del programa, especialmente si tiene For bucles anidados. Debe especificar la variable que aparece en la instrucción For correspondiente.

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

Ejemplo 1

En el ejemplo siguiente se quitan todos los elementos de una lista genérica. En lugar de for each... Instrucción Siguiente: en el ejemplo se muestra For una instrucción ... que recorre en Next iteración en orden descendente. En el ejemplo se usa esta técnica porque el método hace que los elementos después removeAt 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

Consulta también

• List<T>
• Estructuras de bucle
• Instrucción While...End While
• Instrucción Do...Loop
• Estructuras de control anidadas
• Instrucción Exit
• Colecciones