Del básico al intermedio: Comando IF ELSE

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: Paso por valor o por referencia, se explicó de manera bastante práctica y objetiva los conceptos, peligros y precauciones que debes tomar al transferir datos entre diferentes rutinas.

Con base precisamente en ese contenido, así como en lo visto anteriormente, podemos comenzar a hablar de temas un poco más elaborados. Esto se debe a que, en la programación propiamente dicha, no trabajamos únicamente con expresiones matemáticas. Hacerlo, además de ser un desperdicio tremendo de la capacidad computacional y de factorización que una computadora nos ofrece, también limitaría las posibilidades de lo que realmente podríamos lograr.

Por lo tanto, el requisito previo para que puedas entender lo que será explicado a partir de ahora es comprender precisamente lo que se explicó en los artículos anteriores. Si por casualidad tienes dudas sobre por qué algo está ocurriendo o no, consulta los artículos anteriores y procura estudiarlos con calma. No tengas prisa ni intentes apresurarte en los pasos que estoy mostrando cómo deben ser dados.

Dicho esto, antes de comenzar realmente con lo que serán los primeros de diversos temas presentes en este y en próximos artículos, es necesario explicar un término que aparecerá de forma recurrente en los artículos donde hablemos sobre comandos. Para esto, vamos al primer tema de este artículo.

Definiendo qué es una rutina

Todo lenguaje de programación se define dentro de ciertos términos. Para que podamos ser debidamente comprendidos y, al mismo tiempo, que tú entiendas de manera correcta lo que será explicado, necesitamos definir un término muy importante aquí.

Imagen 01

Un bloque de código, como muestra la imagen 01, comienza con una llave de apertura y termina con una llave de cierre. Todo lo que esté dentro de este bloque debe considerarse como una sola entidad. No importa cuántas líneas haya ni qué exista entre la llave de apertura y la llave de cierre. Debes pensar en esto como una única cosa. A esta cosa la llamaremos RUTINA.

Ahora presta atención. Una rutina puede ser tanto un bloque de código, como algo similar a lo que se muestra a continuación.

   {
      ExtAOBuffer[i] = ExtFastBuffer[i] - ExtSlowBuffer[i];

      double sumAO = 0.0;

      for(int j = 0; j < FAST_PERIOD; j++)
         sumAO+=ExtAOBuffer[i - j];

      ExtSMABuffer[i] = sumAO / FAST_PERIOD;
      ExtACBuffer[i] = ExtAOBuffer[i] - ExtSMABuffer[i];

      if ( ExtACBuffer[i] >= ExtACBuffer[i - 1])
         ExtColorBuffer[i] = 0.0; // set color Green
      else
         ExtColorBuffer[i] = 1.0; // set color Red
   }

También puede ser cualquier expresión, como se indica justo después.

ExtACBuffer[i] = ExtAOBuffer[i] - ExtSMABuffer[i];

Incluso una llamada para ejecutar una función o un procedimiento entra en esta categoría. Es decir, todo esto es lo que llamaremos RUTINA. Entonces, cuando se mencione que una rutina será ejecutada, debes entender que podrás usar cualquiera de estas opciones. Desde una llamada a una función o procedimiento, hasta un bloque completo de código que puede contener varias expresiones, llamadas a procedimientos o funciones, e incluso otras rutinas dentro de la rutina original. En fin, expande tu mente hasta el infinito y más allá. Ahora que hemos definido este término, podemos comenzar.

Comando IF: El control supremo

Antes de empezar, me gustaría dejar un pequeño aviso. Aunque todos los comandos en programación deban escribirse en inglés, tú, estimado lector y futuro programador, no estás obligado a usar los comandos en inglés. Existe una manera de evitar esto. Sin embargo, en este momento asumiremos que realmente estás comenzando en el mundo de la programación. Por lo tanto, no te preocupes demasiado por los términos como tal. Intenta comprender el concepto involucrado, ya que saber aplicar el concepto es mucho más importante que memorizar listas de comandos o la sintaxis de cada uno.

Pero entonces, ¿por qué dije que el comando IF es un comando supremo en el título de este tema? Y más aún, ¿por qué estoy comenzando precisamente con el comando IF? ¿No podríamos empezar con otro comando? Claro que sí, estimado lector, podríamos comenzar hablando de otro comando. Sin embargo, si comprendes realmente cómo funciona el comando IF y cómo utilizar lo que fue explicado y demostrado en los artículos anteriores, serás capaz de hacer casi todo en programación. Digo “casi todo” porque falta explicar otro concepto, pero este se comprenderá mejor si tienes una base bien construida sobre otros comandos algo más simples que veremos en breve. Si tienes todos los conceptos necesarios y los aplicas de forma adecuada, literalmente podrás crear cualquier código, y digo cualquier código. Usando solo el comando IF, operadores y variables. Solo esto, nada más. Parece imposible, ¿verdad? Pero puedo asegurarlo. Y con el tiempo verás que mi afirmación también es cierta.

Sin embargo, en este momento comenzaremos entendiendo un concepto muy simple sobre el comando IF. IF significa, literalmente, SI. Siempre que encuentres un comando IF, léelo como un SI. Hacer esto hará que sea mucho más sencillo comprender lo que el comando quiere expresar.

Cuando se ejecuta, un comando IF verifica una condición. Esta condición DEBE ser, y SIEMPRE debe considerarse como un resultado verdadero o falso. SIEMPRE. No importa lo que se esté evaluando o analizando. Lo que determina si el comando IF ejecuta o no la rutina dentro de él es si la condición evaluada es verdadera o falsa. Ya vimos en los artículos anteriores que una condición será falsa si su valor es igual a cero, y será verdadera si el valor es distinto de cero. Al contrario de lo que muchos creen, el comando IF no necesita operadores como mayor, menor, igual o algo similar. Solo necesita saber si la condición es verdadera o falsa. Nada más, y punto.

Para hacer esto un poco más claro, veamos un ejemplo muy sencillo de este concepto en acción.

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

Código 01

Al ejecutar este código, verás en el terminal de MetaTrader 5 algo similar a lo mostrado más abajo.

Imagen 02

Observa que aquí estamos aplicando exactamente lo que explicamos anteriormente. Es decir, utilizamos la línea seis para definir una variable. Después, en la línea ocho, imprimimos un mensaje para analizar lo que tenemos. Sin embargo, exactamente en la línea diez, tenemos un comando de control de flujo: el comando IF. Ahora presta atención, estimado lector. Si info es verdadero, se ejecutará la rutina dentro del comando IF. Si info resulta ser falso, la rutina en el comando IF no se ejecutará, pasando así a la siguiente rutina presente en el código. De este modo, podemos controlar y dirigir el flujo de ejecución de nuestro código. La próxima rutina, en este caso, se encuentra en la línea 13.

Dado que el valor de info es diferente de cero, se ejecutará la rutina dentro del comando IF. Por lo tanto, el resultado es lo que vemos en la imagen 02. Hay algunas cuestiones aquí relacionadas con cómo deberías escribir este comando. Algunas de estas cuestiones son obligatorias, mientras que otras no. Sin embargo, básicamente, la sintaxis del comando IF se presenta de la siguiente manera:

Imagen 03

Aquí puedes percibir claramente cómo se ejecuta el comando. Es una manera bastante simple de entender su sintaxis.

Muy bien, pero ¿qué pasa si no queremos ejecutar la rutina dentro del comando IF cuando la condición es verdadera, sino cuando es falsa? ¿Es posible hacer esto? Esta es una excelente pregunta, y es precisamente aquí donde muchos programadores principiantes terminan enfrentándose a muchos problemas, llegando incluso a quedar completamente confundidos. Esto ocurre porque NO ENTENDIERON el concepto detrás del comando. Vuelvo a repetir: el comando IF ejecutará la rutina dentro de él SI, Y SOLO SI, LA CONDICIÓN ES VERDADERA. Fuera de esto, la rutina dentro del comando IF NO SERÁ EJECUTADA. ¿Cómo es posible? He visto códigos donde un valor es falso y aun así la rutina dentro del comando IF se ejecutaba. Creo que no sabes de lo que estás hablando.

De acuerdo. No discutamos por esto. Hagamos lo siguiente: crearemos un programa simple para verificar si esto realmente puede ocurrir o no. Para ello, forzaremos una condición donde la expresión en el comando IF siempre sea verdadera. Este código se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     if (true)
09.         Print("True condition...");
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. }
13. //+------------------------------------------------------------------+

Código 02

Ahora puedes ver, literalmente, que la prueba realizada en la línea ocho SIEMPRE será verdadera. Por lo tanto, la línea nueve SIEMPRE será ejecutada, sin importar cuántas veces se ejecute el código. La línea nueve SIEMPRE será ejecutada. El resultado se puede ver justo abajo.

Imagen 04

Ahora bien, mencionaste que ya viste un comando IF ejecutar la rutina cuando la expresión era falsa. Muy bien, hagamos que la expresión sea falsa y veamos qué sucede. Esto se muestra en el siguiente código. 

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     if (false)
09.         Print("True condition...");
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. }
13. //+------------------------------------------------------------------+

Código 03

Observa que lo único que modifiqué fue la expresión dentro del comando IF en la línea ocho. Sin embargo, al ejecutar el código, el resultado es el que puedes ver en la imagen a continuación.

Imagen 05

Vaya, ¿dónde está la otra línea que aparecía en la imagen 04? ¿Dónde, demonios, fue a parar? Bueno, estimado lector, esa línea no aparece en la imagen 05 precisamente porque no fue ejecutada. Esto ocurre porque la expresión evaluada en la línea ocho es falsa. Y siempre será falsa. Siendo falsa, la rutina dentro del comando IF JAMÁS será ejecutada. Sin embargo, aquí hay un pequeño detalle al que muchos no prestan atención. Tal vez sea por esto que creíste que una condición falsa hace que la rutina dentro del comando IF se ejecute. Esto se debe a que el resultado de la expresión se invierte de alguna manera. Es decir, lo que era falso pasa a ser verdadero y viceversa.

Presta mucha, pero mucha atención a esto. Dependiendo de cómo escribas el código, podrías obtener un valor final verdadero o falso. Este tipo de situación suele frustrar enormemente, ya que a veces una expresión parece estar correcta, pero debido a algún detalle interno, normalmente relacionado con la precedencia de operadores, la expresión resulta incorrecta. No desde el punto de vista matemático, sino desde la perspectiva del comando IF. Este tema de precedencia es tan importante que merece un artículo completo solo para tratarlo. Sin embargo, como es algo un poco complicado de explicar al inicio —ya que involucra el uso de ciertos comandos para que tenga sentido— voy a posponer este tema por ahora.

De todas formas, puedes estudiar este asunto consultando este tema en la documentación: Reglas de precedencia.

Aunque no entremos en detalles sobre estas reglas, podemos realizar un simple cambio en el código para que la rutina dentro del comando IF en la línea ocho sea ejecutada, incluso cuando aparentemente tenemos una expresión falsa. Esto se logra modificando el código como se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     if (~false)
09.         Print("True condition...");
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. }
13. //+------------------------------------------------------------------+

Código 04

Al hacer este cambio, casi imperceptible, el resultado es el que podemos ver justo abajo.

Imagen 06

Observa que, a primera vista, al mirar descuidadamente el código 04, podríamos pensar que la expresión evaluada es falsa. Sin embargo, nota el símbolo que precede a la palabra reservada false. En la mayoría de los casos, verás que se utiliza el símbolo de exclamación (!). También podemos usar muchos otros recursos. Por ejemplo, sabiendo que la prueba siempre será verificar si el valor es o no igual a cero, podrías escribir algo como lo que se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     if (false | true)
09.         Print("A very crazy condition always true ...");
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. }
13. //+------------------------------------------------------------------+

Código 05

Al ejecutar esto, verás el resultado que se muestra justo abajo.

Imagen 07

En fin, podría seguir aquí mostrando una serie de posibilidades, pero no hay nada mejor que experimentar por ti mismo, entendiendo realmente lo que está ocurriendo. Así que damos por concluido este comando IF y pasamos al siguiente comando, que no existiría sin el comando IF. Me refiero al comando ELSE. Este será explicado en el próximo tema.

Comando ELSE. Este no vive solo.

Un error que algunos principiantes suelen cometer, tal vez debido al tipo de material que usan para intentar aprender a programar, es intentar usar el comando ELSE de manera aislada. Este comando, que de cierta forma podría traducirse como SI NO, siempre acompaña a otro comando. El comando que lo precede dependerá del lenguaje de programación que estés utilizando. Muchos piensan que ELSE siempre está vinculado al comando IF. Sin embargo, en SQL, el comando ELSE puede estar asociado al comando CASE. Esto puede parecer un poco extraño, pero así es como está diseñada esa lengua. Por lo tanto, no supongas que por saber programar en un lenguaje estarás automáticamente capacitado para programar en otro. Muchas cosas pueden adaptarse, pero cada lenguaje de programación tiene sus propias sutilezas y detalles que deben ser comprendidos.

Si lograste entender el comando IF, entender el comando ELSE será mucho más sencillo. Esto se debe a que, cuando está vinculado al comando IF, ELSE solo se ejecutará si la expresión evaluada en el comando IF resulta falsa. Explicar el comando ELSE básicamente se reduce a esto. No hay mucho más que agregar al respecto.

Sin embargo, podemos observar el flujo de ejecución, lo cual hará que las cosas sean aún más fáciles de entender. El flujo en este caso se muestra justo a continuación.

Imagen 08

Al mirar esta imagen 08, notarás que si existe un comando ELSE, estará de alguna manera asociado a un comando IF. Pero aunque a primera vista esto parezca simple y fácil de comprender, en la práctica no siempre es así. Existen algunos cuidados que tú, estimado lector, deberás tener al utilizar un comando IF combinado con un comando ELSE. Más adelante en este artículo hablaremos de esto. Pero antes, ¿qué tal si jugamos y nos divertimos un poco modificando los códigos del tema anterior para incluir el comando ELSE? Bueno, no lo haré con todos, ya que no tiene mucho sentido considerando la simplicidad de lo que estoy mostrando aquí. Por lo tanto, tomemos uno de los códigos y, al añadirle el comando ELSE, quedará como se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     int info = 10;
07. 
08.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway... #1 => ", info);
09. 
10.     if (info)
11.         Procedure(info);
12.     else
13.         Print("Variable info is equal to zero...");
14. 
15.     if (info)
16.         Print("True condition...");
17.     else
18.         Print("False condition...");
19.     
20.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway... #2 => ", info);
21. }
22. //+------------------------------------------------------------------+
23. void Procedure(int & arg1)
24. {
25.     Print(__FUNCTION__, " ", __LINE__, " #1 => ", arg1);
26.     arg1 = 0;
27.     Print(__FUNCTION__, " ", __LINE__, " #1 => ", arg1);
28. }
29. //+------------------------------------------------------------------+

Código 06

Este código 06, que aparentemente parece complicado, en realidad es mucho más simple y directo de lo que podrías imaginar al verlo por primera vez. Y al ejecutar este código 06, obtendrás el resultado que se muestra en la imagen justo a continuación.

Imagen 09

Al observar esta imagen 09, podrías pensar: "Es demasiada información para entender". Pero esto debería motivarte aún más a enfocarte y entusiasmarte. Ahora vamos a desglosar cada punto aquí. De esta manera, comenzarás a comprender mejor cómo usar la combinación IF ELSE.

Para empezar, en la línea seis creamos la variable que utilizaremos en el código. En la línea ocho imprimimos lo que será la primera línea de la imagen 09. Si entendiste el tema sobre el comando IF, sabes perfectamente lo que ocurrirá en la línea 10. En este punto, podremos o no ejecutar la rutina llamada Procedure. Para entender lo que está sucediendo aquí, es necesario que comprendas lo que fue explicado en los artículos anteriores, donde hablamos sobre variables. De cualquier manera, en algún momento ejecutaremos la línea 15. Y en este momento, se ejecutará una u otra rutina. De una forma u otra, imprimiremos un nuevo mensaje en el terminal. Para finalizar, tenemos la línea 20, que imprimirá el último mensaje visible en el terminal.

Este código 06 estará disponible en el anexo para que puedas experimentar con pequeñas modificaciones en él. Aquí van algunas sugerencias para modificar el código. Primero, cambia el valor de la variable en la línea seis, de manera que la prueba en la línea 10 ejecute una u otra rutina. Ejecuta el código después de realizar esta modificación para observar cómo se comporta. Luego, empieza a realizar cambios en los comandos IF, con el objetivo de lograr un comportamiento específico del código, de modo que imprima los mensajes de una forma particular. Cambia las condiciones dentro de la rutina Procedure para que el comando IF en la línea 15 tenga un comportamiento diferente. Con cada cambio que realices, observa el resultado y entiende por qué se generó ese resultado. De este modo, podrás adquirir un buen dominio del comando IF. Este dominio será crucial para comprender los próximos comandos que exploraremos en artículos futuros.

Sin embargo, existe un pequeño problema cuando usamos el conjunto IF ELSE. Para abordar este problema, comencemos con un nuevo tema.

El problema del anidamiento

Cuando utilizamos de forma más intensiva la combinación IF ELSE, suele surgir un pequeño problema conocido como el problema del anidamiento. Este problema aparece cuando tenemos una cascada de comandos IF y ELSE uno dentro del otro. Aunque este problema surge con la combinación de IF y ELSE, no ocurre cuando usamos únicamente comandos IF anidados. Sin embargo, anidar o colocar comandos IF en una estructura tipo cascada no es algo que un programador experimentado haga con frecuencia. Esto se debe a que dicha construcción no tiene mucho sentido.

Para que puedas comprender de lo que estoy hablando cuando utilizo los términos anidamiento y cascada, veamos un ejemplo en el que esto ocurre.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char c1 = 10,
07.          c2 = 0,
08.          c3 = -6,
09.          c4 = 3;
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. 
13.     if (c1)
14.         if (c2)
15.             if (c3)
16.                 if (c4)
17.                     Print("True condition...");
18.     
19.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
20. }
21. //+------------------------------------------------------------------+

Código 07

Aquí tienes un típico ejemplo de anidamiento o cascada de comandos IF. Supongo que ya te estarás preguntando: “Bueno, ¿qué problema hay con programar de esta manera?” Ninguno, estimado lector. Sin embargo, los programadores más experimentados no suelen programar de este modo. Rara vez escriben un código de esta manera. Por lo general, verás que crean un código que funciona de la misma forma que este código 07, pero escrito de una manera diferente. Una posible forma de escribirlo es la que se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char c1 = 10,
07.          c2 = 0,
08.          c3 = -6,
09.          c4 = 3;
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. 
13.     if ((c1) && (c2) && (c3) && (c4))
14.         Print("True condition...");
15.     
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Código 08

Observa que el resultado del código 07 y del código 08 será el mismo. Sin embargo, debes prestar atención al hecho de que el anidamiento o cascada de IF utilizados en el código 07 ha sido reemplazado, en el código 08, por una cadena de operadores lógicos. En este caso, es necesario utilizar operaciones AND. Cualquier otro tipo de operación alterará el comportamiento del código 08, haciendo que no genere el mismo resultado que el código 07. Por lo tanto, siempre que no estés seguro de si el código está cumpliendo correctamente su función, intenta cambiar ligeramente la forma en que lo escribes, de manera que las expresiones a analizar sean más claras para ti.

Sin embargo, el problema del anidamiento no ocurre únicamente con cascadas de comandos IF. Aparece especialmente en la combinación de IF y ELSE. Pero, ¿cómo surge este tipo de problema? Aún no lo entiendo del todo. Bueno, estimado lector, para entenderlo utilizaremos algo similar al código 07, pero le añadiremos un comando ELSE. El código resultante se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char c1 = 10,
07.          c2 = 0,
08.          c3 = -6,
09.          c4 = 3;
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. 
13.     if (c1)
14.         if (c2)
15.             if (c3)
16.                 if (c4)
17.                     Print("True condition...");
18.         else
19.             Print("False condition...");
20.     
21.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
22. }
23. //+------------------------------------------------------------------+

Código 09

Nota que este código se parece mucho al código 07. Sin embargo, aquí en el código 09 tenemos un problema, y uno de los grandes. Si no percibes la magnitud del problema, es precisamente porque necesitas estos artículos para ayudarte a comprender mejor cómo construir tus programas.

El problema aquí, estimado lector, es justamente el ELSE presente en la línea 18. Ahora te pregunto: ¿a qué IF está vinculado este ELSE de la línea 18?

Debido a algo llamado indentación, podrías pensar que este ELSE de la línea 18 está vinculado al IF presente en la línea 14. De hecho, algunas lenguas de programación interpretarán el código de esta manera. Sin embargo, esto no ocurre en todos los lenguajes. En realidad, en la gran mayoría de los casos, esto no sucede, ya que la indentación se utiliza no como parte del código funcional, sino como una forma de organizarlo, haciéndolo más legible.

Por esta razón, y sabiendo que en MQL5 la indentación NO INFLUYE en el comportamiento del código, sino que simplemente lo hace más legible, creer que el ELSE de la línea 18 está vinculado al IF de la línea 14 es un gran error. Tal como está escrito el código, el ELSE de la línea 18 está vinculado al IF de la línea 16.

Ahora, para resolver este problema sin complicar demasiado las cosas y explicar cómo corregirlo, voy a mostrar dos posibles soluciones. Una de ellas es la preferida por una gran mayoría de programadores, mientras que la otra es utilizada por muy pocos. Comencemos con la primera, que es la favorita de gran parte de la comunidad de programadores. Esta solución consiste en separar el código en bloques, lo que obliga al compilador a entender exactamente lo que queremos hacer. Además, hace que el programa sea mucho más legible y fácil de comprender. Esta solución se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char c1 = 10,
07.          c2 = 0,
08.          c3 = -6,
09.          c4 = 3;
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. 
13.     if (c1)
14.         if (c2)
15.         {
16.             if (c3)
17.                 if (c4)
18.                     Print("True condition...");
19.         }
20.         else
21.             Print("False condition...");
22.     
23.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
24. }
25. //+------------------------------------------------------------------+

Código 10

Esta es, de hecho, una excelente solución. Observa que en la línea 14 tenemos el IF al que queremos que el ELSE esté vinculado. Para garantizar que la rutina que será ejecutada, si la expresión en el IF de la línea 14 es verdadera, esté correctamente definida, la colocamos dentro de un bloque. Ya que estamos anidando toda una secuencia de IF, el bloque que comienza en la línea 15 y termina en la línea 19 es, de hecho, la rutina a ejecutarse dentro del IF de la línea 14. Este bloque incluso podría ser colocado dentro de una función o procedimiento fuera del bloque llamado OnStart.

Es muy importante que entiendas esto, estimado lector. Si la expresión del IF de la línea 14 resulta falsa, el programa pasará directamente al comando ELSE para ejecutar la rutina presente dentro de él. Nota que la rutina a ejecutar puede ser cualquier cosa, por lo que es esencial comprender el comando y no limitarte a memorizar la sintaxis o estilos de programación.

Ahora presta atención a este hecho. Si realmente entendiste el comando IF y sabes cómo combinarlo con el comando ELSE, puedes utilizar otra solución para el código 09. Sin embargo, este tipo de solución no es muy adoptada porque, en muchos casos, no hace que el código sea realmente claro. No obstante, dado que aquí estamos trabajando con material didáctico y explicando cómo pueden hacerse las cosas, podemos lograr que el ELSE presente en la línea 18 esté vinculado al IF de la línea 14. Para ello, simplemente vinculamos otros comandos ELSE a los demás IF, como se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char c1 = 10,
07.          c2 = 0,
08.          c3 = -6,
09.          c4 = 3;
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. 
13.     if (c1)
14.         if (c2)
15.             if (c3)
16.                 if (c4)
17.                     Print("True condition...");
18.                 else;
19.             else;
20.         else
21.             Print("False condition...");
22.     
23.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
24. }
25. //+------------------------------------------------------------------+

Código 11

Observa que en este código 11, identificar el vínculo entre el IF de la línea 14 y el ELSE, que ahora es la línea 20, no es tan simple y directo. Es necesario analizar el código cuidadosamente para percibirlo. Sin embargo, tanto el código 10 como el código 11 producirán el mismo resultado al ejecutarse. Es decir, si el IF de la línea 14 resulta falso, se ejecutará la rutina presente en el ELSE correspondiente.

Consideraciones finales

En este artículo comenzamos a trabajar con comandos de control de flujo. Sé que este tipo de material puede ser bastante confuso al principio. Pero si tú, estimado lector, te dedicas a estudiar con calma y practicas constantemente lo que aquí se muestra, creando nuevas soluciones para los problemas que deseas resolver, con el tiempo alcanzarás un nivel de excelencia que pocos logran.

Sin embargo, para lograrlo, es necesario estar siempre estudiando y buscando encontrar una mejor solución para un mismo problema. El hecho de que un problema haya sido resuelto no significa que no exista una solución más eficiente. Siempre hay una manera mejor. Depende de ti estudiar para poder ver más allá de lo evidente.

Un último punto es que en el anexo no tendrás todos los códigos vistos aquí. Solo una parte de ellos estará disponible. Sin embargo, esto no te impide, estudiando el artículo, realizar las modificaciones necesarias para que al final tengas todos los códigos que aquí se han presentado. Además de ser una excelente práctica para el aprendizaje, esto te ayudará a encontrar tu propio estilo. Porque aunque el código sea el mismo, la manera en que está escrito puede variar de un programador a otro, dependiendo, por supuesto, del estilo que cada uno adopte como propio. Así que, estimado lector, ha llegado el momento de empezar a definir tu estilo de programación. Busca encontrar la forma que haga tu código agradable para otros programadores y, al mismo tiempo, te ayude a crear y modificar rápidamente tus propias soluciones.