Del básico al intermedio: Comando FOR

Introducción

El contenido expuesto aquí tiene un propósito puramente didáctico. En ningún caso debe considerarse una aplicación final cuyo objetivo no sea el estudio de los conceptos expuestos.

En el artículo anterior, "Del básico al intermedio: Comando SWITCH", se explicó y demostró el comando switch en su forma más básica y sencilla de uso. Es muy importante que intentes comprender cómo funcionan cada uno de los comandos que hemos visto hasta ahora. No se trata de memorizarlo, sino de entenderlo para poder aplicar cada comando y asimilar los conocimientos adquiridos hasta ahora.

Sé que muchos de ustedes pueden considerar todo esto muy simple y poco profundo, y pensar que podríamos abordar material más avanzado. Sin embargo, basándome en mi experiencia de años programando, he notado que, si los conceptos básicos se asimilan bien, los temas más elaborados y complejos se vuelven mucho más fáciles de entender, incluso en un primer contacto. Y precisamente eso es lo que intento lograr con estos artículos. Mi objetivo es que tú, estimado lector, logres entender cómo funciona cada concepto en su nivel más básico y simple, para que cuando abordemos material más avanzado, puedas comprenderlo con mayor rapidez y sin grandes dificultades.

Muy bien, de todos los comandos existentes en MQL5 cuyo propósito es controlar el flujo de ejecución de una aplicación, solo nos falta abordar uno, que en este caso es el último comando disponible para este propósito dentro de MQL5. Y sí, me refiero al comando FOR. Sin embargo, como probablemente ya te habrás dado cuenta, prefiero dividir la explicación en temas diferentes. Así es más fácil seguir y separar las explicaciones. Dicho esto, iniciemos un nuevo tema.

Premisas del comando FOR

A pesar de que muchos principiantes piensen que hay muchos comandos por aprender, la mayoría de los lenguajes de programación cuentan con pocos. Esto se refiere específicamente a los comandos de control de flujo de ejecución. No debemos confundir esto con llamadas a bibliotecas o palabras reservadas, ya que son cosas completamente distintas. Los comandos de control de flujo suelen ser realmente pocos. Por otro lado, las llamadas a bibliotecas, palabras reservadas, así como funciones y procedimientos auxiliares, pueden llegar a ser muy numerosas dentro de un mismo lenguaje de programación. Por ejemplo, en C/C++, la cantidad de comandos de control de flujo es pequeña. Sin embargo, si observas la cantidad de funciones y procedimientos auxiliares existentes, sin mencionar las llamadas a bibliotecas, te darás cuenta de que es prácticamente imposible que alguien domine completamente el lenguaje. En la práctica, el programador se especializa en un área determinada. Pero, debido a que tiene una base sólida y comprende el lenguaje, es capaz de lidiar con cualquier problema, siempre y cuando se le dé tiempo suficiente para adaptar sus conocimientos a lo necesario para resolver el desafío que se le presenta.

Por esta razón, incluso los programadores más expertos siguen estudiando. Nunca dejan de aprender y de buscarse actualizaciones en relación con las nuevas tendencias. Esto contrasta con lo que muchos piensan cuando comienzan a estudiar programación, pues suelen imaginar que saber algunas cosas ya los convierte en programadores. En realidad, no es así. Es necesario estudiar y mejorar técnicas antiguas constantemente. Solo de esta manera alcanzarás un nivel de excelencia que te permita decir: "YO SOY UN PROGRAMADOR".

Bien, ¿por qué digo todo esto? El motivo es muy sencillo, mi querido lector. Con todo lo que has visto hasta ahora, si decides estudiar y profundizar únicamente en lo que ya se ha mostrado, podrás enfrentarte a prácticamente cualquier problema de programación. Esto se debe a que el comando FOR es, en esencia, un comando de bucle. Sin embargo, ya hemos visto cómo trabajar con bucles utilizando el comando WHILE y la pareja DO WHILE. Entonces, ¿por qué necesitaríamos otro comando para trabajar con bucles? No parece tener mucho sentido, ¿verdad?

Bueno, en realidad, sí que existe una razón para que el comando FOR coexista con los comandos WHILE y DO WHILE. Y la razón es sencilla: hay situaciones en las que el comando WHILE o la pareja DO WHILE no son adecuados. Puede que suene un poco extraño, pero sí, existen contextos donde es preferible utilizar el comando FOR en lugar de los comandos WHILE y DO WHILE. Muchas de estas situaciones están relacionadas con el uso del comando CONTINUE dentro del bucle.

Sin embargo, es importante entender este punto con claridad: el comando FOR es, con mucho, el preferido por los programadores. Esto se debe a que un mismo código que lo utilice es más claro y legible que un bucle escrito con el comando WHILE o DO WHILE. ¿Por qué sucede esto? La razón es que, generalmente —y esto también es importante destacar—, el comando FOR contiene todos los pasos necesarios para el control del bucle dentro de su propia declaración. En contraste, los comandos WHILE y DO WHILE distribuyen ese control en diferentes puntos dentro de la rutina del bucle. Este simple hecho hace que los programadores prefieran el comando FOR, ya que para corregir, modificar o incluso entender el bucle basta con observar su declaración. Esto resulta mucho más sencillo que buscar dichos elementos dentro de la rutina del bucle.

Pero espera un momento. Si sabes que el comando FOR es más sencillo que los demás para controlar un bucle, ¿por qué no lo has mencionado antes? ¿No habría sido mejor mostrarlo antes? Esta es una cuestión algo controvertida, mi estimado lector. Aunque el comando FOR sea, en efecto, más sencillo —al menos al principio—, tiene ciertas características que pueden hacer que sea bastante complejo. Por este motivo, decidí presentar primero los comandos WHILE y DO WHILE y dejar el comando FOR para el final.

Aunque aquí veremos inicialmente el comando en su forma más simple y básica, será mucho más fácil para mí y para ti —si has estudiado los comandos anteriores— explicar cómo trabaja el comando FOR. Quizás debería haber retrasado un poco más esta explicación, ya que aún no he hablado sobre las reglas de precedencia de los operadores. Estas reglas tienen un impacto muy profundo en la programación en general. No obstante, incluso sin haber explicado dichas reglas, podemos hacer algunas cosas utilizando los comandos de control de flujo. Esto me permite crear contenido dirigido a un nivel de lector que está empezando a familiarizarse con la programación, basándose en estos artículos y en la documentación oficial de MQL5. Este sería el escenario ideal. Sin embargo, como sé que muchos ya han tenido algún contacto con la programación, aunque no la entienden del todo, puedo producir algo que se sitúe en un punto intermedio, nivelando así a todos de cara a lo que se verá más adelante.

Muy bien, ha llegado el momento de ver este comando FOR en acción. Para que este primer contacto sea agradable para todos, vamos a tratar este tema por separado.

Comando FOR

La forma más sencilla de introducir un nuevo comando es presentarlo mediante algo que ya hemos visto. Así que haremos lo siguiente: en este primer momento, utilizaremos los scripts que vimos en el artículo donde se explicó el comando WHILE y su pareja DO WHILE. De este modo, la transición será más fluida y no causará sorpresa ni temor a nadie. Por lo tanto, considera este primer contacto como una traducción de aquellos códigos a otros, pero esta vez empleando exclusivamente el comando FOR.

Comencemos con el código más simple de todos, que se muestra 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 01

Dado que este es el código más sencillo, antes de traducirlo para usar el comando FOR, es necesario que conozcas la vida útil de una variable, así como la diferencia entre una variable global y una variable local. Estos conceptos se abordaron en los primeros artículos de esta serie. Por lo tanto, si no comprendes la diferencia entre variables globales y locales, vuelve a los primeros artículos para poder seguir lo que se explicará aquí. Comienza con el artículo Del básico al intermedio: Variables (I).

Una vez que ya poseas el conocimiento necesario, traducimos el código 01 para utilizar el comando FOR. Hay diversas formas de hacerlo y cada una añade o modifica algo en el código. Empezaremos aplicando una variante que hará que el código se parezca mucho al 01. Esta se observa 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.     for( ; 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 02

Este código 02 muestra la primera forma de trabajar con el comando FOR. Observa que únicamente cambiamos la línea 10. Sin embargo, el resultado es el mismo tanto para el código 01 como para el código 02. Este resultado se puede observar en la imagen siguiente.

Imagen 01

Pero es posible que te sientas algo confundido al observar este código 02. Esto se debe a que, si ya has visto otros comandos FOR, el que se muestra en la línea 10 es muy diferente de lo que normalmente se encuentra en la mayoría de los códigos. Precisamente por esta razón, mi estimado lector, es fundamental que asimiles los conocimientos presentados en los artículos anteriores. El comando FOR no es un comando cualquiera. De hecho, se divide en tres partes, cada una con un objetivo muy claro que debes entender en profundidad. Antes de entrar en detalles sobre esta división, revisemos una segunda alternativa para este mismo código 01. Dicha alternativa se muestra 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.     for( ; info; info = info - 1)
11.         Print(__FUNCTION__, " : ", info);
12. 
13.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
14. }
15. //+------------------------------------------------------------------+

Código 03

Ahora presta atención, mi estimado lector. Lo que puedes observar en el código 03 NO ES LO MISMO QUE ANTES. Esto se debe a que el valor de la variable info NO SE MODIFICARÁ como cabría esperar. Sí se modificará, pero el resultado será diferente. Por lo tanto, al ejecutar el código 03, obtendrás el resultado que se muestra a continuación.

Imagen 02

Pero ¿por qué el resultado es diferente? Puede parecer un poco extraño, ¿verdad? ¿Acaso no podríamos utilizar el comando FOR para crear el bucle en este caso? Bueno, mi estimado lector, vayamos por partes. Primero, sí podemos usar el comando FOR para este bucle que estamos construyendo, con el fin de mantener el resultado como se observa en la imagen 01. Sin embargo, en este punto es donde muchos comienzan a sentirse confundidos: será necesario entender la importancia de la variable info. Porque todo dependerá de ella y no necesariamente del bucle FOR. ¿Y por qué lo menciono? Porque, dependiendo del caso, será necesario usar uno u otro método para que el comando FOR produzca el mismo resultado que el código 02 en el código 03. Por esta razón, no debes intentar memorizar cómo trabajar con él, sino entender cómo funciona. Pero para entender cómo funciona el comando.

Es aquí donde las cosas tienden a complicarse y donde muchos desisten al intentar aprender a utilizar el comando. Pero trataré de explicarlo de la manera más sencilla posible. Supongamos que la variable info debe declararse en la línea seis. Da igual la razón, solo queremos que esté definida en esa línea. Segundo punto: queremos que la variable info sea modificada por el bucle, de forma que salga del bucle con un valor concreto. Sin embargo, surge un pequeño problema. Pero no vamos a preocuparnos por ello por ahora, mantendremos las suposiciones por ahora. Si verificas el valor de la variable info en el código 01 después de que pase por el bucle, verás que este valor es igual a cero. Lo mismo ocurre en el código 02. Sin embargo, en el código 03, el valor será uno. Pero, como puedes observar en la imagen 2, el primer valor es diez, no nueve como cabría esperar.

Entonces te preguntas: ¿y si cambiamos el valor de la declaración de diez a nueve en la línea seis? ¿Qué ocurriría? Bueno, mi estimado lector, dejaré esto como una curiosidad para que analices el resultado por ti mismo. Sin embargo, es importante que reflexiones sobre otra cosa: al modificar el valor de la línea seis, existe la posibilidad de que algún cálculo o prueba que se esté ejecutando utilizando la variable info se vea comprometido. Por esta razón, no se recomienda realizar cambios sin comprender primero qué está ocurriendo en el código. La idea no es modificar cualquier punto del código, sino únicamente lo que se está haciendo en la línea diez.

De acuerdo. Podríamos usar simplemente el código 02 y ya está, porque funciona. Incluso podríamos utilizar el código 01, que también funciona. Pero ¿no habría otra forma de usar el comando FOR para resolver nuestro problema? En realidad, sí que existe una manera. Pero esta es un poco más avanzada que el material que planeo presentar en este momento. De todos modos, puedo mostrarte algo más que, al menos, hará que el resultado se acerque más al esperado, como se muestra en la imagen 01.

Así pues, teniendo en cuenta todas las suposiciones anteriores, podemos utilizar un código similar al que se muestra 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.     for(info = info - 1; info; info = info - 1)
11.         Print(__FUNCTION__, " : ", info);
12. 
13.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
14. }
15. //+------------------------------------------------------------------+

Código 04

Este código 04 todavía se considera material básico. Aunque aquí comenzamos a tratar otros aspectos, sigue siendo una forma básica de utilizar el comando FOR. Esto es para que el diagrama de flujo que veremos más adelante tenga sentido. Al ejecutar este código, se obtiene el siguiente resultado, como se muestra a continuación.

Imagen 03

No entiendo. Ahora comenzamos la cuenta en nueve, tal y como se observa en la imagen 01. Sin embargo, la cuenta se detuvo en uno, tal como se ve en la imagen 02. ¿Por qué? ¿Acaso el valor de la variable info, después de pasar por el bucle, es diferente del valor que encontraríamos en los demás códigos, especialmente en el código 01? No, mi estimado lector. El valor de la variable info en todos estos códigos sigue siendo igual a cero después de pasar por el bucle. Sin embargo, el problema aquí es otro. El valor que estamos imprimiendo no es el valor real de la variable info, sino el valor de la variable durante esa interacción específica con el bucle FOR. Puede parecer algo confuso, pero es exactamente lo que está ocurriendo. Para que lo entiendas, necesitamos un código algo diferente. Pero antes de hacerlo, veamos cómo sería el flujo de ejecución dentro del comando FOR. Pasemos entonces a un nuevo tema.

Flujo de ejecución

El flujo de ejecución del comando FOR puede resultar un poco más confuso a primera vista que el de los comandos vistos anteriormente. Sin embargo, una vez que lo entiendas, comprenderás por qué obtuvimos valores tan diferentes en las salidas mencionadas en el tema anterior. A continuación se muestra el diagrama de flujo.

Imagen 04

He utilizado colores diferentes en las flechas para explicar con detalle el funcionamiento del comando FOR. Es posible que te sorprenda ver la presencia del comando IF en este diagrama. Sin embargo, al incluirlo, resulta considerablemente más sencillo explicar lo que está ocurriendo.

De acuerdo, vayamos por partes. La primera parte es la palabra reservada for, que inicia el cuerpo del bucle. Justo después, tenemos la expresión 01. Esta expresión puede hacer muchas cosas, pero se ejecuta únicamente una vez. Normalmente, la usamos para inicializar las variables locales dentro del bucle. Sin embargo, también podemos utilizar esta expresión para ajustar algún valor global, como se hizo en el código 04. Es importante destacar que esta expresión también puede ser del tipo vacía, como ocurrió en los códigos 02 y 03. En estos casos, el compilador simplemente la omite, sin realizar ninguna tarea adicional, ya sea para ajustar o declarar alguna variable o valor. Hay ciertos cuidados que hay que tener en cuenta al declarar variables, pero por ahora nos centraremos únicamente en lo básico: utilizar variables globales o una expresión vacía.

Una vez ejecutada la expresión 01, pasamos al siguiente paso, que en el diagrama de flujo se representa como un comando IF. En este punto, se evalúa la expresión 02. De cierta manera, lo correcto aquí no sería usar un IF, sino un WHILE. Sin embargo, dado que el comando WHILE es un comando de bucle, podría resultar confuso entender que estamos tratando con un comando FOR y no con un WHILE. En cualquier caso, si la expresión 02 es falsa, el bucle FOR se termina. Si la expresión 02 es verdadera, se ejecuta la rutina contenida en el cuerpo del bucle. En este caso, podría tratarse de la línea 11 en los códigos 03 y 04, o del bloque entre las líneas 11 y 14 en el código 02. Después de que se ejecute la rutina, se ejecutará la expresión 03. Este aspecto es particularmente interesante en diversos escenarios, como veremos más adelante. Esto se debe a que, dependiendo de cómo se diseñe el bucle y del objetivo que se le asigne, la parte del bucle en la que se encuentra la expresión 03 puede tener construcciones ligeramente diferentes. Además, la existencia de esta expresión 03, si contiene algo que deba ejecutarse, hace que el bucle FOR sea más seguro que otros tipos de bucles. Esto se debe a que elimina el riesgo de olvidar modificar el valor de la variable que se evaluará en la expresión 02.

Sinceramente, en la práctica, este diagrama de flujo es mucho más fácil de entender que lo que parece a simple vista Sin embargo, puedes ver que he utilizado flechas verdes. Estas flechas indican precisamente cómo se lleva a cabo el bucle. Las flechas en rojo, por otro lado, muestran cuándo se termina el bucle.

Así que, si observas y analizas con calma, te darás cuenta de que tiene sentido que la variable info tenga el valor cero después de pasar por el bucle. Pero también tiene sentido que, al mirar el código 03, el valor mostrado en el terminal sea info + 1.En los demás casos, el valor es bastante diferente del que se esperaba inicialmente.

Genial. Creo que estoy empezando a entender el comando FOR. Parece bastante sencillo, aunque a veces resulte un poco confuso. Pero, entre nosotros, mencionaste que el IF presente en el diagrama de flujo debería ser un comando WHILE. ¿Cómo es eso? No terminé de entender esta parte, ¿podrías explicarlo mejor? Esta cuestión —o al menos así es como la considero— es relativamente simple de entender, sin necesidad de entrar en otros detalles sobre el bucle FOR. Porque sí, hay ciertos aspectos que lo complican para principiantes. Pero si quieres entender por qué menciono que el IF del diagrama debería ser sustituido por un comando WHILE, basta con observar los códigos 01 y 02 y compararlos. Como las expresiones 01 y 03 están vacías, lo único que queda aquí es algo que podría reemplazarse directamente por un comando WHILE. Por eso mencioné que el IF visto en el diagrama debería ser, en realidad, un comando WHILE.

Quizá no te hayas dado cuenta, mi querido lector, pero estoy evitando adentrarme en un modelo más avanzado del comando FOR en la medida de lo posible. No quiero que este primer contacto que estás teniendo con este comando termine por desanimarte a comprenderlo. Sin embargo, tampoco quiero que pienses que el comando FOR no es necesario y que podría sustituirse por algún tipo de construcción que utilice comandos WHILE o incluso la pareja DO WHILE, por lo que voy a mostrarte un caso en el que esto no podría hacerse. Pero lo veremos en otro tema.

Comando FOR vacío

Lo que veremos aquí debe considerarse más como una curiosidad que como algo que debas utilizar en la práctica. En realidad, lo que se mostrará solo se emplea en la programación cotidiana. Yo mismo, en todos estos años como programador, he usado lo que se mostrará solo en contadas ocasiones. Sin embargo, puede ocurrir que en algún momento te encuentres con un comando FOR muy exótico, pero que funciona correctamente. Dado que tardaremos en hablar de ciertos temas y podrías toparte con algo de este tipo, necesito mostrarlo ahora. De lo contrario, podría olvidarme de mencionarlo más adelante. Para explicarlo, utilizaremos un código muy sencillo y tomaremos precauciones para evitar problemas. Cuando hablamos del comando WHILE, usamos un código similar al siguiente.

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

El objetivo de ese código era crear un tipo de bucle infinito con una salida bien definida: el uso de la tecla ESC. Perfecto. No obstante, es posible usar un comando FOR completamente vacío para el mismo propósito, es decir, crear un bucle infinito. Para demostrarlo, utilizaremos el siguiente código.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     for (; ; )
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.         if (TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE)) break;
15.     }
16. 
17.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
18. }
19. //+------------------------------------------------------------------+

Código 06

Ahora presta mucha atención, mi estimado lector, porque no repetiré este detalle. Si has observado los códigos anteriores de este artículo, habrás notado que todos incluían información en lo que sería la expresión 02. Esto hacía posible que el bucle FOR se terminara en algún momento. Sin embargo, puede haber casos en los que necesites que el bucle FOR no termine, al menos no por alguna condición definida dentro del cuerpo del comando. En tal caso, puedes utilizar una expresión 02 vacía. Cuando esto sucede, el bucle NO SE DETENDRÁ, al menos no por una condición indicada en el comando. Dicha condición, si existe, ocurrirá dentro de la rutina del bucle. Como puedes observar en el código 06, la condición que detiene el bucle está definida en la línea 14. Sin embargo, a diferencia de lo que muchos podrían imaginar —que sería necesario declarar alguna expresión en un bucle FOR—, este puede declararse perfectamente como se muestra en la línea 8 del código 6. Al hacerlo, el compilador entenderá que el bucle es infinito y cualquier programador también lo comprenderá.

Por eso, cuando hablé de bucles en el tema del comando WHILE, mencioné que los bucles son algo con lo que debemos tener mucho cuidado. Si cometes un error, podrías enfrentarte a un problema potencialmente serio. Así que mantente atento siempre que vayas a crear bucles en tus códigos.

Para demostrar que el código 06 realmente funciona y no entrará en un bucle infinito, puede observarse su resultado en la animación que se muestra a continuación.

Animación 01

Sin embargo, te lo menciono para que, si te encuentras con un código que utilice un comando FOR vacío, no te desesperes sin saber lo que sucederá. Ahora creo que ya sabes qué pasará y cómo terminará el bucle, en caso de que efectivamente se detenga.

Consideraciones finales

En este artículo hablamos de los conceptos más básicos sobre el comando FOR. Es fundamental asimilar y comprender todo lo que se ha mostrado aquí. A diferencia de otros comandos, este comando FOR tiene algunas peculiaridades que lo vuelven muy complejo con rapidez. Así que, querido lector, no permitas que este tipo de material se acumule. Comienza a estudiar y practicar lo visto en este artículo. Para ello, utiliza los códigos presentados en los artículos anteriores e intenta modificarlos para usar el comando FOR en cada bucles presente.

Dado que este era el último comando por abordar, todo lo que se muestre a partir de ahora combinará estos conceptos básicos explicados hasta la fecha. Sin embargo, aún no podemos hablar de conceptos intermedios, ya que quedan otros conceptos básicos por explicar que son tan importantes como los que se han visto hasta ahora. No obstante, ahora me siento un poco más libre para empezar a mostrar formas ligeramente más avanzadas de implementación de código, con el propósito de que los conceptos básicos que aún deben presentarse puedan explicarse adecuadamente, sin las limitaciones de hasta ahora.

Así que estudia con mucha atención el material presentado en todos los anexos hasta la fecha. Nos vemos en el próximo artículo. Un fuerte abrazo, que tengas buenos estudios y hasta pronto.