Fundamentos

Estructura de control WHILE

Básicos Definiciones Fundamentos

En el anterior artículo iniciamos el aprendizaje de las estructuras de control viendo la estructura condicional más básica. En esta ocasión, comenzaremos a ver las iterativas, es decir, las que van repitiéndose. Para ello, comenzaremos viendo la estructura de control WHILE.

Repetición innecesaria de código

Como en el ejemplo del artículo anterior, vamos a plantear un pequeño problema y a intentar resolverlo con lo que hemos aprendido hasta ahora.

Nuestro pequeño problema es sencillo y se trata de obtener la suma de los 1000 primeros números enteros positivos. Es decir, queremos calcular el sumatorio de 1 hasta 1000 sin aplicar ninguna fórmula para obtener este cálculo, sino simplemente sumando número a número y haciendo una operación por línea de código. Veamos cómo quedaría en nuestro pseudocódigo particular y con las herramientas que tenemos.

sumatorio = 0
sumatorio += 1
sumatorio += 2
sumatorio += 3
sumatorio += 4
...
sumatorio += 998
sumatorio += 999
sumatorio += 1000
IMPRIMIR sumatorio

Si recordamos los operadores de asignación, nos será familiar el operador +=, el cual únicamente cogía el valor de la variable y le sumaba la expresión de la derecha. En el caso que hemos visto, en cada línea de código cogemos la variable sumatorio y le sumamos el valor de la derecha.

Obviamente, no hemos escrito el programa al completo, pues éste tendría un total de 1001 líneas. Pero sí que podemos fijarnos en que esas 1000 primeras líneas tienen mucho en común. ¿Tenemos alguna manera de repetir esa instrucción con el valor actualizado? Ahí es donde entran las estructuras de control iterativas.

La estructura de control WHILE

La estructura de control WHILE, traducida como MIENTRAS se utiliza para ejecutar una serie de instrucciones mientras la condición que le indiquemos sea cierta. En otras palabras, el código que esté dentro del WHILE será ejecutado indefinidamente hasta que le proporcionemos alguna forma de detenerse.

Reconstruyamos el ejemplo anterior con esta nueva estructura:

sumatorio = 0
incremento = 1
WHILE (incremento <= 1000) {
  sumatorio += incremento
  incremento += 1
}
IMPRIMIR sumatorio

Con siete líneas de código tenemos el mismo resultado, en comparación con las 1001 líneas de código anteriores.

Revisión línea por línea

Vamos a ver qué hace este programa línea por línea:

  • línea 1: nuestra variable sumatorio empieza con valor 0.
  • línea 2: iniciamos una variable que llamaremos incremento y que empieza por el valor 1. Nos va a servir para sumar todos los números.
  • línea 3: aquí tenemos a nuestra sentencia WHILE. Estamos diciendo en esta línea algo prácticamente exacto a si lo leyéramos naturalmente. Es decir, en esta línea leemos un “mientras la variable incremento sea menor o igual a 1000″, que será la condición que le decimos al WHILE de cuándo debe parar. O sea, lo que haya dentro del WHILE se ejecutará mientras que la variable incremento no supere el valor 1000.
  • línea 4: es donde, realmente, estamos calculando nuestro sumatorio. En esta línea vemos que la variable sumatorio va sumándose a ella misma más la variable incremento. Esta variable incremento deberá ir creciendo de uno en uno para que el sumatorio sea correcto al final del programa, lo que haremos en la siguiente línea.
  • línea 5: una vez hemos sumado la variable incremento, necesitamos que en la siguiente iteración su valor sea uno más. Así pues, en esta línea incrementamos el valor de incremento en una unidad. Podríamos también haber utilizado uno de los operadores de incremento que vimos en un artículo anterior al estar sumando únicamente la unidad, por lo que podríamos haber escrito incremento++ igualmente.
  • línea 6: cerramos las llaves de nuestro WHILE porque ya no tenemos más instrucciones que queramos repetir.
  • línea 7: mostramos la solución por pantalla.

Es decir, y repitiéndonos de nuevo, el programa irá sumándole a la variable sumatorio el valor de incremento, el cual irá creciendo uno a uno, hasta que ésta última llegue a valer más de 1000. Se ve mejor si utilizamos una traza.

Trazas en programación

Llamamos traza en programación a escribir, paso a paso, el estado de un programa línea por línea. Sería como trazar los pasos que se van dando y cuánto vale cada variable en cada momento del programa. Vamos a ver la traza de este programa (no completa, pues serían algunas miles de filas) en una pequeña tabla.

PasosumatorioincrementoExplicación
10No existeEn la primera línea de nuestro código, creamos la variable sumatorio con valor 0
201En la segunda línea, creamos la variable incremento con valor 1
301Evaluamos en el WHILE si incremento es menor o igual a 1000, dando como resultado un valor verdadero
411Al entrar en el WHILE ejecutamos la instrucción que suma el valor de incremento a la variable sumatorio
512Aumentamos en una unidad el valor de la variable incremento
612Volvemos a evaluar el WHILE y vemos que incremento sigue siendo menor o igual a 1000, por lo que la condición sigue siendo verdadera
732Sumamos lo que valía la variable sumatorio, que era 1, al nuevo valor de incremento, que ahora es 2. Por tanto, sumatorio pasa a valer 3
833Aumentamos de nuevo en la unidad el valor de incremento
Seguiríamos evaluando en nuestro WHILE el que incremento fuera menor o igual a 1000. Si no lo fuera, se lo sumaríamos a sumatorio una y otra vez hasta que incremento coja el valor 1001

Y así actúa la estructura de control WHILE sencillamente. Mientras la condición que le hayamos indicado sea siempre verdadera, seguirá ejecutando las instrucciones que tiene dentro una y otra vez.

Ahorro de centenares de líneas de código

Con solo esta sentencia nos hemos ahorrado cientos de líneas de código. Imaginad que tuviéramos que sumar un millón de números, o casos más prácticos como que tuviéramos que aumentar el precio de diez mil productos o tuviéramos que hacer cambios en una enorme base de datos de clientes. Esta sentencia, junto con otras que veremos que refinan ciertas situaciones, nos permitirá no tener que duplicar un número enorme de veces el código.

Problemas con las estructuras de control iterativas

Sólo comentar de pasada que tenemos que tener mucho cuidado con las estructuras de control iterativas, tanto estas como las que veremos en este artículo, pues pueden llevar a errores fatales. Sin embargo, dedicaremos los problemas más habituales que pueden aparecer en un futuro artículo. Antes, debemos ver cómo implementarlas en PHP.

Deja una respuesta