Del básico al intermedio: Comando WHILE y DO WHILE

Introducción

El contenido expuesto aquí tiene como objetivo exclusivamente la enseñanza didáctica. En ningún caso debe considerarse como una aplicación final cuyo propósito no sea el estudio de los conceptos mostrados.

En el artículo anterior Del básico al intermedio: Comando IF ELSE, se explicó cómo estudiar un código para implementar un control de flujo condicional. Esto, de manera que, dependiendo de la expresión que se analizara, pudiéramos elegir si ejecutar una u otra rutina.

Aunque el comando IF, junto con su aliado ELSE, es lo suficientemente útil como para permitirnos implementar cualquier código utilizando únicamente estos dos, en la práctica no sería muy prudente. Esto se debe a que, en diversos puntos, el código se volvería algo difícil de comprender de manera rápida y sin mayores complicaciones.

Precisamente por esta razón, los lenguajes de programación no se limitan al dúo IF ELSE. Para hacer que el código sea más simple y fácil de entender, estos lenguajes implementan un mayor número de instrucciones, incluyendo instrucciones de bucle.

Las instrucciones de bucle, en términos generales y sin querer alarmarte, querido lector, son, y tal vez seguirán siendo por mucho tiempo, las instrucciones de control de flujo más peligrosas que existen. Esto se debe a que cualquier pequeño error durante la programación o implementación de un bucle puede causar un desastre. Un error, y listo: tu código entrará en un bucle infinito, lo que es algo temible y causa de numerosas renuncias por parte de principiantes. Esto los deja completamente aterrorizados cuando necesitan implementar un bucle en sus códigos.

Básicamente, existen dos formas de crear un bucle en un código. La primera es utilizando funciones y procedimientos fuera de la rutina principal, donde se implementaría el bucle. La segunda es mediante algún comando de control de flujo.

Como el uso de comandos es algo más sencillo, lo haremos en este momento. Sin embargo, a medida que avancemos, te mostraré cómo crear bucles utilizando funciones y procedimientos. A diferencia de lo que muchos puedan imaginar, existe un motivo válido para usar una función o incluso un procedimiento para crear un bucle, en lugar de usar un comando, como veremos dentro de poco. Pero explicar el motivo de esto será el tema de otro artículo, en un momento más oportuno.

Hay un requisito previo para poder seguir este artículo. Comprender el concepto de variables y constantes, ya hablamos sobre eso, pero más allá de conocer sobre variables y constantes, lo más importante aquí es entender cómo el ancho de bits afecta los valores, y cómo el tipo de la variable puede influir en su comportamiento.

Si no tienes idea de lo que estoy hablando, consulta Del básico al intermedio: Operadores, donde explico algunos aspectos relacionados con este tema. Aunque el contenido allí es básico, será suficiente para que sigas lo que se explicará aquí. No obstante, no dejes de revisar los otros artículos para lograr una mejor comprensión de todo lo que será presentado en este texto.

Bien, en este momento me encuentro en un pequeño dilema. A pesar de que el comando FOR es virtualmente más simple para la creación de bucles, siendo en muchos casos el preferido de los programadores, contiene ciertos inconvenientes. Sin embargo, los demás comandos que permiten crear bucles son un poco más peligrosos que el comando FOR. Entonces, mientras decido cuál mostrar primero, haremos lo siguiente: iniciemos un nuevo tema para explicar algunas cosas importantes sobre este asunto.

Por qué usar bucles

Muchos programadores sienten pavor, literalmente, cuando necesitan crear un bucle en sus códigos. Otros lo evitan al máximo y solo lo hacen cuando no tienen otra opción. ¿Pero a qué se debe este miedo al uso de bucles? La razón es sencilla: los bucles son un riesgo asumido. Cada vez que entras en uno, quedas a merced de tu propio código, necesitando tomar algún tipo de medida para finalizar el bucle cuando sea necesario. Esto se debe a que, muchas veces, un bucle puede entrar en un ciclo infinito. Y sin darte cuenta, podrías pensar que el computador está tardando demasiado en procesar algo, cuando en realidad lo que ha ocurrido es que el código ha quedado atrapado en un bucle infinito.

Otra razón por la cual muchos temen el uso de bucles es que, en muchas ocasiones, es difícil analizar lo que está ocurriendo dentro de ellos. Esto sucede, simplemente, porque en situaciones reales, un bucle necesitará ejecutarse miles o incluso millones de veces antes de finalizar. Y dependiendo del tipo de cálculo que se esté realizando, esto puede tomar horas para que la aplicación entregue el resultado final. Sé que para muchos esto puede parecer inconcebible. ¿Cómo es posible que un programa tarde horas en completar una tarea? Pero sí, querido lector, existen situaciones en las que, efectivamente, el tiempo necesario para completar una tarea puede llegar a ser de horas. Sin embargo, aquí, como el objetivo es la didáctica, y la mayoría de los bucles que muchos de ustedes crearán serán pequeños, con una magnitud de miles de iteraciones, esto normalmente hará que la aplicación tarde segundos o pocos minutos en finalizar. Por ejemplo, en aplicaciones destinadas al entrenamiento de una red neuronal.

En mi otro perfil, estoy mostrando cómo implementar este tipo de cosas: una red neuronal completamente escrita en MQL5 puro. Ese tipo de aplicación, en mi opinión, es de nivel intermedio, ya que solo necesitas un buen conocimiento en MQL5 y en la matemática involucrada. El resto es fácil y sencillo de realizar.

Bien, sin embargo, aún no he respondido a la pregunta del título de este tema: ¿por qué usar bucles? La razón es la simplicidad que aportan a tu código. El uso de bucles te permitirá controlar cuántas veces algo debe realizarse, sin necesidad de escribir manualmente o usar CTRL+C y CTRL+V para repetir algo. Pensemos en el siguiente objetivo: al principio, mostré un código muy simple cuyo propósito era calcular el valor factorial de un número cualquiera. El código en sí es bastante sencillo, como seguramente recordarás. Para quienes no lo vieron, lo muestro a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar counter = 0;
07.     ulong value = 1;
08. 
09.     Print("Factorial of ", counter, " => ", value);
10.     counter = counter + 1;
11.     value = value * counter;
12.     Print("Factorial of ", counter, " => ", value);
13.     counter = counter + 1;
14.     value = value * counter;
15.     Print("Factorial of ", counter, " => ", value);
16.     counter = counter + 1;
17.     value = value * counter;
18.     Print("Factorial of ", counter, " => ", value);
19.     counter = counter + 1;
20.     value = value * counter;
21.     Print("Factorial of ", counter, " => ", value);
22. }
23. //+------------------------------------------------------------------+

Código 01

Este Código 01, para números pequeños, puede ser aceptable. Sin embargo, a medida que los números crecen, las cosas comienzan a complicarse. Incluso para un factorial de 20, ya sería algo muy complicado de ajustar, además de la enorme posibilidad de errores al implementar el código, incluso utilizando CTRL+C y CTRL+V. Así, en el mismo artículo en el que aparece este Código 01, desarrollamos otro que puede verse a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Factorial();
07.     Factorial();
08.     Factorial();
09.     Factorial();
10.     Factorial();
11. }
12. //+------------------------------------------------------------------+
13. void Factorial(void)
14. {
15.     static uchar counter = 0;
16.     static ulong value = 1;
17. 
18.     Print("Factorial of ", counter, " => ", value);    
19.     counter = counter + 1;
20.     value = value * counter;
21. }
22. //+------------------------------------------------------------------+

Código 02

Aquí, puedes notar que ya tenemos un código un poco más compacto, lo que facilita un poco más el uso de CTRL+C y CTRL+V para cálculos factoriales pequeños. Pero, ¿y si necesitas calcular el factorial de un número mayor? ¿Cómo lo harías? Bueno, suponiendo que no sobrepases el límite superior de 64 bits del valor ulong, necesitarías copiar y pegar las capas del cálculo factorial varias veces. Esto sin contar todo el esfuerzo para ajustar el código cada vez que necesites calcular un nuevo factorial. Definitivamente, algo mucho más laborioso que satisfactorio. Por esta razón, el uso de un bucle hace que el código sea mucho más sencillo de manejar. Esta sería la explicación del porqué usar bucles.

Entendido y explicado esto, podemos comenzar a hablar de los comandos que se utilizan para implementarlos. Y aunque el bucle FOR es el favorito de gran parte de los programadores, incluido quien te escribe, comenzaremos con otro comando. Este tiene dos formas de uso, y resulta más sencillo de explicar y, por ende, de comprender que el bucle FOR, que incluye algunos detalles que me llevaron a decidir empezar por otro.

Comando WHILE y DO WHILE

A pesar de la ligera broma en el título de este tema, este bucle es muy sencillo de entender, ya que sigue los mismos principios que el comando IF. Sin embargo, hay ciertas precauciones que debemos tomar. Esto se debe a que no es raro que termines cometiendo errores al usar este comando. Y la razón es simple: OLVIDO. Muchos programadores se olvidan de ajustar o corregir la condición que hace que este bucle termine. Por increíble que parezca, incluso programadores con mucha experiencia cometen este error. Así que aquí tienes el primer aviso: ten cuidado al implementar un código que utilice este comando.

La diferencia entre el comando WHILE y la pareja DO WHILE es bastante sencilla. WHILE a veces no ejecuta la rutina interna, mientras que DO WHILE ejecutará la rutina al menos una vez. Básicamente, eso es todo. Simple, ¿verdad? Sin embargo, esto no reduce los riesgos involucrados. Por lo tanto, comencemos con el más simple de ellos: el comando WHILE. Su flujo de ejecución puede observarse en la imagen a continuación.

Imagen 01

Nota que se parece mucho a lo que vimos con el comando IF en el artículo anterior. Tanto es así que el tema relacionado con la expresión tiene el mismo significado y principio de uso aquí también. Es decir, el bucle solo ejecutará la rutina definida en él si, y solo si, la expresión es verdadera. En otras palabras, la expresión debe ser diferente de cero. Por eso, el primer comando que expliqué fue el comando IF. Entender ese comando es fundamental para todo aquel que desee convertirse en un buen programador o, incluso, para quienes desean crear programas de forma ocasional, solo por diversión.

Maravilloso. Como tenemos algo muy parecido al comando IF, y espero que tú, querido lector, hayas hecho tu tarea de estudiar el comando IF, aquí seremos un poco más directos con el tema.

Primero, haremos un código muy simple, solo para que empieces a familiarizarte con lo que es un bucle. No para que te golpees con él, sino para que veas cómo funciona en la práctica. Para esto, analicemos el código a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
09. 
10.     while (info)
11.     {
12.         info = info - 1;
13.         Print(__FUNCTION__, " : ", info);
14.     }
15. 
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Código 03

Este Código 03 ilustra muy bien cómo funciona un comando WHILE. Cuando lo ejecutes, producirá el siguiente resultado, que se muestra a continuación.

Imagen 02

La región marcada en esta Imagen 02 es precisamente la región creada por el bucle, siendo la rutina ejecutada por el comando WHILE. Ahora, echemos un vistazo rápido y entendamos por qué ocurrió esto. Y por qué la cuenta regresiva comenzó en nueve y terminó en cero. Para esto, debes observar dos cosas. La primera es el hecho de que, en la línea seis, inicializamos la variable con el valor diez. Cuando el comando WHILE evalúa la expresión, que en este caso es el valor de la variable definida en la línea seis, y determina que este valor es verdadero, el bucle comienza. Sin embargo, y este es el segundo punto a observar, antes de mostrar el valor en el terminal, en la línea 13, usamos la línea 12 para disminuir en una unidad el valor de la variable info. Por esta razón, la cuenta va de nueve a cero. Y termina en cero porque el valor cero se considera un valor que representa el estado booleano falso.

¿Pero qué pasaría si, en lugar de restar una unidad de la variable info en la línea 12, incrementáramos una unidad? ¿Entraría el bucle en un loop infinito? Bueno, querido lector, esta es una pregunta muy interesante que tú mismo puedes experimentar para descubrir qué sucederá. Pero antes de hacerlo, ¿qué tal si entendemos por qué el bucle no entrará en un loop infinito en este caso específico?

A diferencia del sentido común, donde imaginamos que podemos ir de menos infinito a más infinito, en computación las cosas no funcionan exactamente así. Existe un límite para cualquier valor que una computadora pueda expresar. Este límite está definido por el ancho de bits del tipo de variable utilizada. Ya hemos hablado de esto en otro artículo. Precisamente debido a esta limitación (y cabe destacar que existen lenguajes en los que esta limitación no existe, pero este no es el caso, ya que estamos trabajando con un lenguaje tipado). Si el cambio del valor se realiza de forma que en algún momento alcance el valor cero, esto implicará que, en algún momento, el bucle se detendrá. No importa cuánto tiempo tome, en algún momento el bucle terminará. Sin embargo, existen algunos problemas, precisamente y específicamente aquí, en este comando WHILE. Pero para no confundirte en este momento exacto, dejaremos ese tema para otra oportunidad. Muy probablemente hablaré de ello en el próximo artículo.

Muy bien, sobre el comando WHILE, básicamente tenemos esto que mencionar. Sin embargo, hay un pequeño detalle aquí que tal vez sea interesante explicar en este momento. Normalmente, cuando queremos que un código funcione de manera controlada, especialmente al hablar de bucles, además de la condición normal para salir del bucle, añadimos una segunda condición. Esta condición actúa como una válvula de escape, permitiendo forzar el cierre del bucle para que el código continúe con su ejecución normal.

Dado que MQL5 es un lenguaje basado en eventos, y sobre esto hablaremos más en el futuro, no es muy común crear bucles que esperen a que ocurra uno u otro evento. Esto es más típico en lenguajes como C o C++, donde el lenguaje no está basado en eventos.

En estos casos, los bucles se crean para generar una pausa controlada en la aplicación. Dicha pausa permanecerá activa durante un tiempo predeterminado, o hasta que ocurra un evento también predeterminado. Sin embargo, no es muy común hacerlo directamente con un bucle WHILE. Esto se debe a que este comando solo ejecutará su rutina si la expresión es verdadera. Y en muchos casos, eso no es exactamente lo que deseamos. No obstante, en situaciones de salida de emergencia, este bucle WHILE es una mejor opción. Si la expresión es falsa desde el principio, no se ejecutará la rutina del bucle WHILE, lo cual, en muchas ocasiones, puede ser crucial para evitar influencias no deseadas en el cierre del bucle, basadas en ciertos criterios que veremos más adelante cuando hablemos del bucle DO WHILE.

Hagamos lo siguiente: crearemos de manera intencional un bucle que, en teoría, sería infinito. Sin embargo, añadiremos una condición para que pueda cerrarse. Este tipo de situación puede observarse a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 5;
07. 
08.     Print("Press ESC to finish counting...");
09. 
10.     while (!TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE))
11.     {
12.         info = info - 1;
13.         Sleep(200);
14.         Print(__FUNCTION__, " : ", info);
15.     }
16. 
17.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
18. }
19. //+------------------------------------------------------------------+

Código 04

En el Código 04, tenemos un bucle en la línea diez que, en teoría, debería ejecutarse para siempre. Sin embargo, no lo hará si el usuario presiona la tecla ESC. Observa que esta advertencia solo se muestra una vez, antes de que el bucle se inicie. Si el usuario pierde este mensaje, que se imprimirá en el terminal, la situación podría volverse algo problemática. En el terminal verás algo similar a lo que se muestra a continuación.

Imagen 03

Atención al hecho de que, en esta ocasión, el valor de la variable info pasó por cero y, aun así, el bucle continuó. Esto se debe a que la expresión que determina cuándo terminará el bucle ahora está vinculada a la condición de que se presione la tecla ESC. Es decir, estamos esperando un evento para que el código pueda continuar. Otra prueba que también podemos realizar, y que es mucho más común en códigos escritos en MQL5, consiste en verificar si el código ha sido interrumpido. Para comprobar esto, basta con modificar la línea diez del Código 04 por la que se muestra a continuación.

    while ((!TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE)) && (!IsStopped()))

Este simple cambio permitirá que el bucle en el Código 04 se cierre, tanto al presionar la tecla ESC como al ser interrumpido por el usuario al eliminar el script del gráfico. Algo muy simple, ¿verdad, querido lector? Por esta razón, no tiene sentido temerle a los bucles. Sin embargo, seguimos teniendo el problema de que el mensaje en la línea ocho puede perderse durante alguna ejecución, lo que podría hacer que el usuario no sepa que presionando ESC también puede cerrar la aplicación.

Una forma de resolver este inconveniente es colocando la línea ocho dentro del bucle. Pero hagámoslo usando la variación del comando WHILE, es decir, el comando DO combinado con WHILE. Para separar adecuadamente las cosas, abordemos este tema con una nueva perspectiva.

Comando DO...WHILE

Nuevamente, no pude resistir la broma en el título de este tema. Sin embargo, esta broma es casi una descripción literal del comando DO WHILE. Esto se debe a que, aunque es un solo comando, en realidad funciona como una pareja, al igual que ocurre con el dúo IF ELSE. Sin embargo, aquí las cosas operan de una manera un poco diferente.

Creo que ya habrás comprendido que el comando WHILE, como se explicó en el tema anterior, solo ejecutará su rutina al menos una vez si la condición de la expresión es verdadera. No obstante, debido precisamente al hecho de que tenemos un comando DO, que significa literalmente, HACER, antes del comando WHILE, que significa literalmente, MIENTRAS, logramos que la rutina dentro del bucle se ejecute al menos una vez. Este comportamiento, en muchos escenarios, resulta interesante e incluso altamente deseable, ya que permite modelar de forma más precisa cómo ciertas rutinas deben operar cuando necesitan ejecutarse al menos una vez.

Para ejemplificar esto, tomemos el Código 04 y modifiquémoslo de manera que el mensaje en la línea ocho aparezca de vez en cuando. Sé que podríamos hacer esto directamente en el Código 04, pero supongamos que no sería posible lograrlo sin duplicar la línea ocho. Sin embargo, lo más importante es que queremos que el bucle se ejecute al menos una vez, independientemente de lo que haya ocurrido antes de que comience a ejecutarse.

Así, tenemos el código que se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     do
09.     {
10.         if (((info / 5) * 5) == info) Print("Press ESC to finish counting...");
11.         info = info - 1;
12.         Sleep(200);
13.         Print(__FUNCTION__, " : ", info);
14.     }while (!TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE));
15. 
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Código 05

Al ejecutar este código, verás algo similar a lo que se muestra a continuación.

Imagen 04

Aquí se están realizando algunas cosas que, de cierta manera, son bastante interesantes de comprender. Esto se debe a que algunas de las acciones en este Código 05 pueden no tener mucho sentido al principio. Sin embargo, si has estado prestando atención y estudiando cuidadosamente los artículos que he publicado, podrás entenderlas con relativa rapidez.

Bien, vamos a entender qué está ocurriendo aquí, y por qué ahora tenemos el mensaje indicando que se presione ESC, mostrándose de vez en cuando. Como puedes notar, debido a que ahora la verificación para continuar o no ejecutando la rutina dentro del bucle se realiza en la línea 14, toda la rutina interna del bucle se ejecuta al menos una vez. Ahora comprenderás por qué existe el comando DO en esta combinación con el comando WHILE.

Ahora presta mucha atención a lo que voy a explicar, porque es muy importante. La idea aquí es la misma que con el comando WHILE. Es decir, el bucle se ejecutará hasta que la expresión del comando WHILE sea falsa. Pero, ¿cómo podrías saber dónde comienza el bucle? Si eliminases la línea ocho, no sabrías exactamente dónde comienza el bucle. Peor aún, la rutina que debería estar dentro del bucle, desde la línea diez hasta la línea trece, NO SERÍA vista como parte de una rutina del bucle. Sino simplemente como un bloque de código común. Por otro lado, el comando WHILE presente en la línea 14 sí sería un bucle. Sin embargo, tendría una rutina vacía, ya que no habría otros comandos ejecutándose dentro del bucle. Este simplemente esperaría a que se presionara la tecla ESC para finalizar.

Sin embargo, gracias a la combinación entre el comando DO y el comando WHILE, tanto el compilador como otros programadores podrán identificar que el bucle comienza en la línea ocho y termina en la línea 14. Puede parecer un poco confuso entender esto de inmediato, pero se vuelve mucho más claro si eliminas el comando DO de la línea ocho, lo que haría que el código quede como se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08. 
09.     {
10.         if (((info / 5) * 5) == info) Print("Press ESC to finish counting...");
11.         info = info - 1;
12.         Sleep(200);
13.         Print(__FUNCTION__, " : ", info);
14.     }while (!TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE));
15. 
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Código 06

Sin embargo, debido a este pequeño cambio en el código, algo que podría pasar completamente desapercibido el resultado es completamente diferente. Por esta razón, para aclararlo mejor, en lugar de utilizar una imagen, mostraré una animación para explicar lo que ocurre. Esta puede verse a continuación.

Animación 01

Aquí es donde reside uno de los peligros de crear bucles sin prestar la debida atención. Nota que ya no tenemos el mismo comportamiento mostrado en la Imagen 04. Aquí, lo que debería ser el cuerpo del bucle fue ejecutado como si fuera una simple secuencia de código común. Sin embargo, se detuvo ahí, y el código ingresó al bucle que se encuentra en la línea 14. Debido a esto, si la condición de finalización del bucle estuviera vinculada a algo que debería realizarse dentro de la rutina del bucle, ese algo jamás ocurriría. Como consecuencia, un bucle que debería funcionar y tener un punto de finalización nunca se cerraría, entrando así en el temido bucle infinito.

Entonces, veamos cómo y por qué el mensaje de la línea 10 se imprime de vez en cuando. Para esto, es necesario entender la expresión presente en el comando IF de la línea diez. Esta expresión, que para los humanos puede parecer absurda, tiene pleno sentido para una computadora, siempre y cuando estemos usando un lenguaje tipado, como es el caso de MQL5.

En otro artículo ya se mencionaron algunos aspectos sobre cálculos matemáticos en lenguajes de programación. Así, esta expresión aparentemente trivial y sin sentido, que consiste en dividir el valor de la variable info por un número y luego multiplicar el resultado por ese mismo número, puede parecer una tontería. Sin embargo, insisto en que revises los artículos anteriores si estás comenzando a adentrarte en la programación. Esto se debe a que, al realizar esta operación, el resultado puede o no ser igual al valor original de la variable info. Si es igual, el mensaje será impreso. Si es diferente, no lo será.

Como este código estará en el anexo, podrás estudiarlo con más calma. El único cuidado que debes tomar es usar el mismo valor tanto en la división como en la multiplicación, y siempre realizar la división antes de la multiplicación. Pero ten precaución al usar valores enteros. Usar valores de tipo punto flotante no funcionará debido a ciertos aspectos que abordaremos en otro momento.

Para finalizar este tema, veamos cómo sería el esquema del flujo de ejecución de la pareja DO WHILE. Esto se puede observar a continuación.

Imagen 05

Nota que no es tan complicado como podría parecer antes de verlo en acción. Comprender este flujo de ejecución es mucho más importante que memorizar comandos y su sintaxis. Entendiendo cómo funciona el flujo de ejecución, podrás pensar de manera más clara. A medida que practiques y estudies cómo cada pequeña decisión tomada durante la ejecución del flujo influye en el resultado final, te convertirás en un programador, incluso si solo lo haces en tu tiempo libre. Serás competente, capaz incluso de aprender otros lenguajes de programación, sin quedar limitado a uno en particular.

Consideraciones finales

Muy bien, en este artículo intenté, de la manera más didáctica y sencilla posible, presentar algo que muchos consideran un verdadero desafío, casi como el monstruo escondido bajo la cama de muchos programadores principiantes. Sin embargo, creo haber demostrado que, si tienes paciencia, calma y, sobre todo, prestas atención a lo que estás implementando, ya sea algo creado por ti o por otro programador cuyo código deseas estudiar y comprender, podrás hacer cosas bastante interesantes. Algunas de ellas, de forma mucho más sencilla y sin desperdiciar tu tiempo en trivialidades.

Esto se debe a que los bucles, si se utilizan e implementan correctamente, pueden ahorrarte mucho tiempo en el diseño y la implementación de ciertas condiciones. Tanto es así que los códigos vistos al inicio de este artículo, donde mostré la factorización de números sin bucles, pero utilizando llamadas secuenciales, pueden escribirse de una manera mucho más compacta y, por ende, mucho más interesante. Esto se muestra a continuación. Solo para demostrar que podemos hacer muchas cosas útiles con bucles.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar counter = 0;
07.     ulong value = 1;
08. 
09.     while (counter < 5)
10.     {
11.         counter = counter + 1;
12.         value = value * counter;
13.     }
14. 
15.     Print("Factorial of ", counter, " => ", value);
16. }
17. //+------------------------------------------------------------------+

Código 07

Prueba modificar el Código 02 para que utilice un bucle en lugar de esas llamadas secuenciales que están entre las líneas seis y diez. Si no logras encontrar una forma de hacerlo. No te preocupes, en el próximo artículo volveremos a hablar sobre bucles, ya que aún no hemos cubierto todo sobre ellos. Así que comienza a practicar antes de que sea demasiado tarde.