¡Es la hora, es la hora!, es la hora de seguir programando.

Tal como lo prometimos, ahora les traemos la cuarta parte de esta guía que está sacando chispas muchos esperaban, en la cual seguiremos viendo el maravilloso mundo de la programación de una manera sencilla.

Continuaremos justo desde donde terminamos la última vez, así que sin más que decir, los esperamos después del salto.

Cómo aprender a programar y no morir en el intento – Parte 4

Nota: Si es primera vez que entran en estos tutoriales, les recomendamos leer las partes anteriores para estar al día con lo que ya hemos cubierto:

• Parte 1.
• Parte 2.
• Parte 3.

Y tal como es costumbre, partiremos por revisar los contenidos de esta edición:

Contenidos:

1. Iteraciones condicionales múltiples y uso de más de una condición.
2. Switch: Otra iteración condicional.
3. Ciclos o búcles.

Así que sin más que decir, manos a la obra:

1.- Iteraciones condicionales múltiples y uso de más de una condición.

En la edición anterior de esta saga, comenzamos a ver lo que son las iteraciones condicionales y como aplicarlas cuando dentro de un programa necesitamos tomar un camino u otro, en su mayoría mutuamente excluyente, a partir de una condición dada. La simpleza de su utilización pudimos apreciarla a través de los ejercicios resueltos.

Pero la programación, como la vida, siempre se complica, y eso es lo que haremos ahora.

En los ejercicios anteriores hicimos uso de condiciones excluyentes para las iteraciones, o sea, algo como “Si se da esta condición, haga esto, si no, haga esto otro”, lo cual es bastante sencillo de entender y aplicar. Sin embargo, cuando estemos realizando programas a más alto nivel comunmente nos encontraremos con situaciones donde debamos evaluar multiples iteraciones, como por ejemplo “Si se da esta condición, haga esto, si no se da, pero se da esta otra, haga esto y si no se da ninguna de las 2, haga esto otro”. Con palabras es algo complicado, pero viendo según sentencias, sería algo así:

Si (condición)
    sentencia 1;
Si no
    Si(condición)
        sentencia 2;
    Si no
       sentencia 3;

Ahora, tal como mencionamos en el tutorial anterior, dentro de un Si, pueden ir una infinidad de Si y Si no, lo mismo dentro de un Si no. Sin embargo, lo único que debemos recordar es que siempre un Si no debe ir precedido de un Si.

Teniendo eso claro, ¿Qué pasa ahora si dentro de nuestro Si debemos evaluar más de una condición o bien una de 2 posibles?.

Ahí es donde empezamos a utilizar el concepto de más de una condición. Dentro de un Si, podemos evaluar el número de condiciones que nosotros queramos, utilizando los operadores && para “y”, y || para “ó”. Por ejemplo, si dentro de un Si necesitaramos evaluar la condición de que una persona tuviese más de 18 años y su nombre fuera Juan, utilizaríamos algo como esto:

Si (edad > 18 && nombre=="Juan")
    sentencia 1;
Si no
    sentencia 2;

Por otro lado, si quisieramos evaluar alguna de las 2 condiciones como ciertas, bien que su edad sea mayor a 18, o su nombre fuese Juan, haríamos algo como esto:

Si (edad > 18 || nombre == "Juan")
    sentencia 1;
Si no
    sentencia 2;

De esta forma, mediante esos operadores, podemos evaluar una serie de condiciones, tanto excluyentes, como adherentes. Esta evaluación puede mezclarse con iteraciones múltiples, según lo necesitemos.

2.- Switch: Otra iteración condicional.

A pesar de que el Si y Si no (if y else en los lenguajes reales) es la iteración condicional más utilizada, existe una bastante útil al momento de evaluar distintos escenarios dentro de un programa, la cual es el famoso Switch, el cual evalúa el valor de una variable y a partir de ese valor presenta distintas sentencias a partir de posibles casos que se puedan dar.

Su funcionamiento es bastante parecido a la iteración anterior, pero en este caso lo que basicamente se hace es:

Evaluación de la variable:

Si la variable es 'x':
    Sentencia 1;
Salir;

Si la variable es 'y':
    Sentencia 2;
Salir;

Si la variable es 'z':
    Sentencia 3;
Salir;

Dentro de una iteración condicional Switch, podemos presentar todos los escenarios que deseemos. Lo único a tener en consideración es que debemos conocer todos los posibles valores que pueda tomar la variable para así plantear sus posibles desenlaces.

Además incluimos una nueva sentencia: Salir. Esta es utilizada debido a que por defecto, una iteración condicional de tipo Switch recorre siempre todos los posibles escenarios (a pesar de que no ejecuta las sentencias correspondientes a escenarios donde el valor no corresponde), por lo que al agregar Salir, ejecutará las sentencias correspondientes y luego saldrá de la iteración, ahorrando tiempo de ejecución.

Adicionalmente es bueno añadir un escenario de tipo defecto (default en los lenguajes reales de programación), al cual se ingresará si el valor ingresado en la variable no corresponde a ninguno de los escenarios posibles planteados. Esto quedará mucho más claro más adelante cuando

Las iteraciones condicionales de tipo Switch son especialmente ideales al momento de plantear menús dentro de un programa, ya que el usuario ingresará una opción y conoceremos todos los posibles valores para plantear sus sentencias.

Existen una gran cantidad de casos donde podemos utilizar Si y Si no, o Switch, eso dependerá del gusto de cada uno. Sin embargo en algunos casos no podremos utilizar Switch, ya que la evaluación de valor se debe hacer con comparaciones exactas (Si el valor es igual a 1 por ejemplo) y no comparaciones mediante operadores (Si el valor es mayor a cierto valor).

Veamos ahora un ejemplo para que todo esto quede más claro. Utilizaremos un Switch (llamándolo evaluar) para determinar opciones de un menú. (comentarios en negrita, cursiva y entre /* y */).

Inicio
/* Damos inicio al programa */

Numero opción;
Letra nombre;
/* Declaramos una variable de tipo número y de nombre opción la cual utilizaremos para que el usuario ingrese la opción del menú a la cual quiere ingresar, y también una variable de tipo letra y de nombre 'nombre' la cual usaremos dentro de las opciones del menú como ya veremos. */

Principal( )
{
/* Definimos la función “Principal” que es donde irá el cuerpo del programa, además abrimos parentesis de llaves para incluir dentro todo lo concerniente a esta función. Ya adentraremos el tema de las funciones. */

    mostrar("Seleccione una opción: \n");
    mostrar("1.- Ingresar usuario \n");
    mostrar("2.- Borrar usuario \n");
    mostrar("3.- Listar usuarios \n");
    /* Mediante la sentencia mostrar, desplegamos un mensaje en pantalla para que el usuario sepa que debe ingresar su opción y      luego vamos mostrando las opciones con la misma opción. Utilizamos "\n" para indicarle al programa que haga un salto de línea */

    leer(%numero, opcion);
    /* Mediante la sentencia leer, recabamos el dato que quiere ingresar el usuario. A leer le damos como parámetro primero el tipo de valor que queremos recolectar, o sea número con un % antes para acostumbrarnos al formato de lenguajes reales y luego le damos la variable donde almacenaremos el valor, o sea, opcion */

    evaluar(opcion)
    {
        /* Llamamos a la iteración evaluar y le damos como parámetro el dato en el cual nos basaremos, o sea, opcion, luego abrimos llaves para dar inicio al contenido de la iteración */

        caso '1':    mostrar("Ingrese el nombre del usuario: ");
                     leer(%letra,nombre);
                     .......
                     salir;
        /* Definimos el caso '1', que es decirle al programa "en caso de que la evaluación nos diga que la opción seleccionada fue 1, haga esto" y luego definimos las sentencias a ejecutar, finalizando con salir, tal como lo explicamos anteriormente. */

        caso '2':    mostrar("Ingrese el nombre del usuario a borrar: ");
                     leer(%letra,nombre);
                     ......
                     salir;
        /* Luego definimos el caso 2, tal como el anterior */

        caso '3':    mostrar("Los usuarios son: ");
                     .......
                     salir;

        /* A continuación el caso 3 */

        caso 'defecto': mostrar("Seleccionó una opción no válida");
                        salir;
       /* Y finalmente el caso 'defecto' en caso de que haya seleccionado una opción no definida para el menú. Luego de esta última definición, cerramos el paréntesis de llave correspondiente a la iteración evaluar y el paréntesis correspondiente a la función principal, y finalizamos el programa mediante Fin. */
    }
}
Fin

Como podemos ver, hemos utilizado el nuevo tipo de iteración y definido todos sus posibles escenarios. Tal como indicamos anteriormente, en las iteraciones de este tipo solo podemos evaluar valores fijos y no hacer comparaciones mediante operadores. Esto nos dará la pauta sobre que tipo de iteración utilizar para cada caso.

Hora de pasar al último punto del tutorial de hoy:

3.- Ciclos o Búcles

Un aspecto importantísimo de la programación, es el uso de ciclos o búcles, los cuales son utilizados en el 99,9% de los programas de alto nivel, ya veremos porque.

Hasta este momento, hemos desarrollado una serie de programas donde damos inicio, ejecutamos algunas sentencias de forma ordenada, secuencial y estructurada y los finalizamos. Con los conocimientos que poseemos hasta este punto, si quisieramos ejecutar una operación un determinado número de veces, tendríamos que definir una línea para cada vez que queramos ejecutar la operación, lo cual si el número de repeticiones es largo, se convertiría en una operación tediosa y tendríamos un programa con un gran número de líneas.

Para economizar este proceso y hacer todo mucho más sencillo es que aparecen los ciclos, los cuales nos permiten ejecutar una sentencia un número de veces que nosotros determinemos a partir de una condición dada.

Existen 3 ciclos comunes que se utilizan, cada uno de ellos con características especiales e ideales para cierto tipo de usos:

1. Mientras (o while en los lenguajes reales): Se ejecuta si es que la condición dada se cumpla y correrá tantas veces según se respete esa condición.
2. Haga Mientras (o do-while en los lenguajes reales): Se ejecuta tantas veces según se respete la condición dada. A diferencia del Mientras, este ciclo se ejecuta al menos una vez.
3. Para (o for en los lenguajes reales): Se ejecuta si es que la condición dada se cumple inicialmente y mientras se siga cumpliendo. A diferencia de los 2 anteriores, en sus parámetros definimos todas las condiciones necesarias.

Las diferencias quedarán claras en los ejemplos que daremos más adelante. Tal como en el caso de las iteraciones condicionales, existen situaciones ideales para el uso de cada uno de ellos. Sin embargo, hay una serie de casos donde podemos usar cualquiera de ellos de forma eficiente.

Ahora, cuando usamos un ciclo, debemos definir ciertas cosas, como:

1. Una variable a utilizar en la condición que definirá la duración del ciclo, la cual puede ser definida por nosotros o por un dato leído desde teclado.
2. Un valor inicial para esa variable, una vez más, definido por nosotros o por el usuario.
3. Una condición para evaluar esa variable y que definirá la duración de la ejecución del ciclo.
4. Una instancia de cambio de la variable. Esta instancia, debe ir modificando el valor de la variable para que en algún momento cumpla la condición que define la duración del ciclo, de lo contrario, el ciclo se ejecutará infinitamente.

La diferencia entre cada tipo de ciclo se ve principalmente en la forma en que definimos y utilizamos las cosas de la lista anterior.

Veamos unos ejemplos para que esto quede más claro:

Haremos un programa donde enumeremos del 1 al 100, utilizando los 3 tipos de ciclos descritos con anterioridad. (comentarios en negrita, cursiva y entre /* y */ )

Inicio
/* Damos inicio al programa */

Numero num = 1;
/* Declaramos una variable de tipo Numero y nombre num, y le damos el valor inicial 1, que es desde donde partiremos a enumerar */

Principal( )
{
    /* Definimos la función “Principal” que es donde irá el cuerpo del programa y abrimos llaves. Ya adentraremos el tema de las funciones */

    mientras(num<=100)
    {
        mostrar(%numero, num);
        num++;
    }
    /* Definimos un ciclo de tipo mientras y le decimos que la condición es que se ejecute mientras num sea menor o igual a 100,    dentro de el mediante la sentencia mostrar desplegamos el valor actual de la variable y luego con el operador de incremento lo aumentamos en uno y se vuelve a ejecutar. De esta forma la primera vez que entre mostrará 1 y luego irá aumentando y mostrando hasta que llegue a 100 */

    haga
    {
        mostrar(%numero, num);
        num++;
    }mientras(num<= 100);

    /* Ahora hacemos la misma operación pero usando un ciclo de tipo haga-mientras. Definimos las mismas operaciones pero a diferencia del caso anterior, ahora declaramos la condición al final. Como requisito de este tipo de ciclos, el mientras del final debe ir con un punto y coma al final. Recordemos que este ciclo se ejecutará al menos una vez */

    para(num = 1; num<= 100; num++)
    {
        mostrar(%numero, num);
    }
    /* Y finalmente hacemos el mismo proceso con un ciclo de tipo 'para'. La diferencia con los 2 anteriores es que ahora dentro de sus parametros establecemos toda las condiciones para la ejecución de este ciclo. Partiendo por un valor inicial para num, en este caso 1, la condición de duración que es mientras sea menor o igual a 100 y el incremento para que se cumpla esta condición. Dentro del ciclo solo ponemos la sentencia mostrar porque ya hemos definido lo demás */
}
Fin

Como podemos ver, hemos declarado la misma operación mediante 3 ciclos distintos. Cada uno de ellos desplegará el mismo resultado, los números de 1 a 100, pero la forma en que definimos estos ciclos es diferente. Con más práctica podremos ir viendo que tipo de ciclo es adecuado para que situación. Idealmente a la sentencia mostrar en los 3 casos podríamos haberle añadido un salto de línea, porque como esta declarado mostrará los números uno al lado del otro. Como es un ejemplo no es necesario que lo definamos.

Es bueno añadir que dentro de un ciclo, cualquiera de ellos, podemos definir todas las operaciones que estimemos conveniente, incluidas iteraciones condicionales y todo lo que hemos visto hasta ahora como muestra de datos, lectura de datos de teclado, etc.

Además es bueno también recordar que todo ciclo debe tener un fin, por eso debemos ser cuidadosos al momento de definir las condiciones de duración, ya que un ciclo que corrá eternamente matará nuestro programa.

Tal como debemos definir cuidadosamente el fin, un punto a considerar es que un ciclo no necesariamente debe siempre ejecutarse, es por eso que definimos la condición de inicio y duración. Por ejemplo, podemos condicionar el inicio de un ciclo a que cierta variable porte cierto valor y en caso de que no lo tenga, el ciclo nunca se ejecute.

El trabajo con los ciclos puede presentar cierta complejidad en sus inicios, pero a medida que vayamos avanzando se irá simplificando.

Con esto cerramos la lista de contenidos de esta edición del tutorial, definiendo que para el próximo número, veremos:

1. Introducción a los arrays o arreglos.
2. Arreglos unidimensionales: Vectores.
3. Arreglos bidimensionales: Matrices.

Todo a la misma batihora, en el mismo baticanal.

Como siempre, este tutorial ha sido desarrollado, probado y documentado por el equipo de Cómo Lo Hago, por lo que cuenta con nuestro Sello de Garantía.

Cualquier duda, problema o comentario, pueden dejarnos unas líneas en el área habilitada a continuación.

Esperamos que este tutorial haya sido de utilidad para Uds.

Muchas gracias por leer y será hasta una próxima edición.