Capítulo 6: Estructuras repetitivas

Publicado por P. Ruiz en

La estructura for

En las estructuras anteriores, el programador desconoce a priori el número de veces que va a repetirse un determinado bloque. En do while y do until, lo máximo que podemos decir es que se ejecutarán al menos una vez.

Por el contrario, la orden for está pensada para que definamos, desde el principio, el número de repeticiones que van a llevarse a cabo. No obstante, se trata de una estructura muy flexible, que nos permitirá ajustar su comportamiento a nuestras necesidades. Incluso podremos conseguir que se comporte como una estructura while.

Su sintaxis general es la siguiente:

PowerShell-UD06-013

Para entenderla, veamos lo que significa cada uno los argumentos que aparecen entre paréntesis:

  • inicialización: serán una o más instrucciones, separadas por comas, que se ejecutarán sólo una vez antes de comenzar la repetición. Normalmente se utiliza para inicializar una variable que se utilizará en el control de la repetición.

  • condición: se evaluará antes de cada repetición (incluida la primera) y sólo se ejecutará el bloque cuando su valor sea $true. Por lo tanto, la repetición terminará la primera vez que la condición devuelva el valor $false.

  • incremento: serán una o más instrucciones, separadas por comas, que se ejecutarán al final de cada repetición. Esta parte suele utilizarse para modificar la variable que será comprobada en la condición para controlar las repeticiones del bucle.

Probablemente, la mejor forma de entenderlo sea a través de un ejemplo. Veamos cómo mostrar en pantalla los números del 1 al 5:

PowerShell-UD06-014

Su funcionamiento será el siguiente:

  • Comienza ejecutando la inicialización, que se hará sólo la primera vez (almacena el valor 1 en la variable $i).

  • A continuación, se evalúa la condición (comprueba si el contenido de la variable $i es inferior o igual a 5).

  • Si la condición devuelve $true, se ejecuta el bloque de código (en este caso el cmdlet Write-Host) y se produce el incremento (se le suma 1 al valor de $i).

  • Después, volverá a evaluarse la condición, repitiendo todo el proceso.

La repetición continuará hasta que la condición devuelva el valor $false. En ese caso, la ejecución continuará con la instrucción que haya después de la estructura for.

Debes tener en cuenta que los argumentos de for van separados por caracteres de punto y coma (;)

Como puedes suponer, el resultado del código anterior será como el que se muestra en la siguiente imagen:

PowerShell-UD06-015

En realidad, es muy sencillo escribir un bucle while que se comporte como un bucle for. En concreto, el ejemplo anterior podríamos escribirlo de la siguiente forma:

PowerShell-UD06-016

Y el funcionamiento seguirá siendo idéntico:

PowerShell-UD06-017

Como puedes ver, ha bastado con poner la inicialización justo encima del bucle y el incremento como última instrucción del bloque de código.

Incluso podemos hacer que un bucle for se comporte como un bucle while. Basta con dejar vacíos la inicialización y el incremento:

PowerShell-UD06-018

Un aspecto interesante, que hemos mencionado al principio, es que tanto en la parte de inicialización, como en la de incremento, podemos incluir más de una operación, siempre que las escribamos separadas por comas. Así, por ejemplo, podríamos crear un bucle for con este aspecto:

PowerShell-UD06-050

Observa que ambas operaciones de inicialización están agrupadas con paréntesis. Esto es para que PowerShell las trate como elementos individuales de una colección de expresiones.

Una curiosidad es que, en la parte del incremento, PowerShell ya espera una lista de operaciones, por lo que no es necesario agruparlas explícitamente con paréntesis. Cada operación de incremento se ejecuta secuencialmente como parte del final del bucle.

PowerShell-UD06-051

En cualquier caso, nada nos impide usar paréntesis también el el incremento, si nos parece más coherente.

Esta idea nos podría llevar a estructuras como esta:

PowerShell-UD06-052

O como esta otra:

PowerShell-UD06-053

Pero, pese a resultar interesantes para ampliar nuestro conocimiento sobre el funcionamiento de la estructura for, no te recomiendo que las utilices de forma habitual. El motivo es que tu código será mucho más difícil de interpretar.

Por último, para terminar este apartado, a continuación incluimos un esquema que resume las principales características de las estructuras repetitivas estudiadas hasta el momento:

Esquema tipos de bucles

Actividades resueltas: Trata de resolver el siguiente bloque de actividades, utilizando la estructura repetitiva for, antes de consultar la respuesta:

    1. Escribe un script que solicite un número entero, se asegure de que es mayor que 1, y nos diga si dicho número es primo.

      Nota: Un número es primo cuando solo es divisible por él mismo y por 1. De lo contrario, será un número compuesto.

      PowerShell-UD06-041

    2. Escribe un script que nos pida una frase y la escriba al revés.

      Nota: Para resolverlo, pueden resultar útiles un método y una propiedad:

      • El método SubString permite obtener parte del contenido de un texto, a partir de una posición. Por ejemplo, el siguiente código mostraría en pantalla una «B«:

        $direccion = "221B Baker Street"
        Write-Host $direccion.SubString(3,1)

        Como puedes suponer, el primer valor de SubString indica la posición (contando desde cero), y el segundo la cantidad de caracteres.

      • La propiedad Length representa el número de caracteres de una variable. Por ejemplo,

        Write-Host $direccion.Length

        Mostraría en pantalla el valor 17, que es el número de caracteres que tiene la variable $direccion de nuestro ejemplo.

      PowerShell-UD06-042

    3. Escribe un script que pida un número y nos diga por qué números es divisible. El bucle debe comprobar cada número entre él mismo y el uno.

      PowerShell-UD06-043

    4. Crea un script que muestre en pantalla la tabla de multiplicar del número 8. La salida debe tener un formato parecido al siguiente:

      Tabla de multiplicar del 8:

      8 x 1 = 8

      8 x 2 = 16

      8 x 3 = 24

      8 x 10 = 80

      Una mejora inmediata es que, en lugar de la tabla del 8, el script pida un número al usuario y escriba la tabla del número introducido.

      PowerShell-UD06-044

      PowerShell-UD06-045

    5. Crea un nuevo script que reutilice el resultado del ejercicio anterior para mostrar en pantalla las tablas de multiplicar del 1 al 10.

      Cada tabla irá encabezada por un texto que informe del número al que corresponde.

      PowerShell-UD06-046