Del básico al intermedio: Comando SWITCH

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: Directiva #include", hablamos sobre los conceptos básicos para utilizar la directiva de compilación #include. Pero aquello fue solo un paso inicial para que pudieras asimilar adecuadamente y dedicar tiempo a estudiar los comandos de control de flujo de ejecución. Es muy necesario que los estudies y asimiles bien, porque son muy importantes. Aunque todavía no hemos terminado. Aún nos falta hablar de dos comandos más presentes en MQL5. Estos dos comandos son relativamente más complejos, al menos en lo que respecta a los aspectos que requieren atención en el momento de utilizarlos. Por ello, trataré de abordarlos con mucha calma.

Esto se debe a que cualquier error que cometas como programador al utilizar estos dos últimos comandos hará, con total certeza, que pierdas mucho tiempo tratando de identificar dónde está la falla en tu código.

Si los comandos anteriores te resultaron intensos y complicados, prepárate, porque estos dos últimos requieren mucha atención. Sin embargo, al final de estos artículos, al menos entenderás cómo funciona cada uno. Por lo tanto, para seguir el contenido que se explicará aquí, necesitas saber trabajar con variables y constantes, así como manejar el comando IF. Si dominas esto, estarás listo para continuar y comprender el contenido de este artículo.

Como es costumbre, iniciemos un nuevo tema. Así podremos empezar a hablar sobre el penúltimo comando, que será explicado a continuación.

Comando SWITCH

Este comando, que literalmente significa "interruptor", puede sustituir al comando IF. Sin embargo, hay un pequeño detalle que debes considerar para poder utilizar el comando SWITCH en lugar del comando IF.

Para entender cuándo y cómo esto ocurrirá, necesito que comprendas otra cosa, mi querido y estimado lector. En programación, existen situaciones no poco comunes en las que evaluamos una misma variable con el objetivo de encontrar un valor MUY ESPECÍFICO. Esa expresión "muy específico" es la clave. Esto se debe a que el valor no puede ser mayor, menor o aproximado. Tiene que ser EXACTAMENTE el que estamos buscando. Ni más ni menos. EXACTAMENTE.

Cuando se da esta situación, podemos prescindir de usar múltiples comandos IF y emplear un único comando SWITCH. Sin embargo, es importante tener en cuenta que el tamaño en bits y el formato utilizados en el comando SWITCH influyen profundamente en su uso.

En resumen, solo podrás usar SWITCH como sustituto de varios comandos IF si la variable que se evaluará es la misma en diferentes condiciones IF. Únicamente puedes verificar si la variable es igual a un valor determinado. No es posible verificar si es mayor o menor que un valor dado. Además, el tamaño en bits influye en el resultado de la evaluación. Esto resume de manera muy simple la función del comando SWITCH.

Vista así, la idea puede parecer complicada o, como mínimo, poco práctica. Sin embargo, es justo lo contrario de lo que podrías estar pensando. El comando SWITCH se utiliza con frecuencia en diversas situaciones. Aunque a primera vista pueda parecer limitante y difícil de usar, es bastante útil.

Lo que realmente hace que el comando SWITCH sea algo confuso y complicado para muchos programadores principiantes o incluso para programadores ocasionales que lo usan como hobby es precisamente la forma en que opera en diferentes lenguajes y escenarios. Pero aquí nos centraremos exclusivamente en cómo trabajar con el comando SWITCH dentro de MQL5. Como su funcionamiento es muy similar al de C/C++, puedes buscar documentación de estos lenguajes para complementar y profundizar en ciertas características del comando SWITCH. Esto se debe a que solo abordaremos lo básico, es decir, cómo funciona el comando y algunas precauciones que debes tomar. Sin embargo, hay mucho más material sobre este tema si investigas el comando en el contexto de C/C++.

Bien, creo que he transmitido una idea de lo que viene a continuación y dónde puedes profundizar si lo deseas. Ahora es el momento de sumergirnos de lleno en este comando y empezar a explorar sus posibilidades. Para ello, comenzaremos con un ejemplo muy sencillo, sin utilizar aún el comando propiamente dicho. Así que echemos un vistazo al código siguiente.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar counter = 5;
07. 
08.     if (counter == 5) Print("The counter value is five."); else
09.     if (counter == 3) Print("The counter value is three."); else
10.     if (counter == 1) Print("The counter value is one."); else
11.         Print("The counter value is unknown.");
12. }
13. //+------------------------------------------------------------------+

Código 01

Sé que muchos lo mirarán y dirán: "Vaya, qué código tan básico". Sí, lo sé, pero realmente necesitamos empezar con algo muy básico. De lo contrario, podrías volverte loco tratando de entender lo que ocurrirá después.

Solo con observar este código queda claro lo que se mostrará en el terminal de MetaTrader 5, por lo que considero completamente innecesario mostrar cuál será el mensaje impreso. Ahora bien, si no puedes deducirlo simplemente mirando este código, querido lector, te sugiero encarecidamente que te detengas inmediatamente, retrocedas y comiences desde el principio revisando los artículos iniciales. Empieza por el primer artículo titulado "Del básico al intermedio: Variables (I)". No creas que podrás aprender a programar saltándote pasos, porque no es así. Comienza por comprender los conceptos y comandos iniciales antes de intentar adentrarte en terrenos desconocidos.

Muy bien, continuemos. Aquí se puede ver claramente que tenemos exactamente lo que se definió al principio de este tema. Es decir, tenemos una única variable cuyo valor se evalúa en diferentes comandos IF. Y en cada uno de ellos estamos verificando un único valor. No estamos buscando si es mayor o menor, sino un valor exacto. Este es el punto clave. Es decir, una vez que tenemos algo similar a lo que se muestra en el código 01, podemos usar un comando más elegante. Ese comando es el comando SWITCH.

Teniendo esto bien claro, veamos otro código que generará el mismo resultado al ejecutarse. A continuación se muestra este código.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar counter = 5;
07. 
08.     switch (counter)
09.     {
10.         case 5:
11.             Print("The counter value is five.");
12.             break;
13.         case 3:
14.             Print("The counter value is three.");
15.             break;
16.         case 1:
17.             Print("The counter value is one.");
18.             break;
19.         default:
20.             Print("The counter value is unknown.");
21.     }
22. }
23. //+------------------------------------------------------------------+

Código 02

Ahí lo tienes, querido lector. Este código 02 es similar al código 01 y produce exactamente el mismo resultado, no hay ninguna diferencia entre ellos. Pero quizá estés pensando: "Vaya, esto parece mucho más complicado. Prefiero usar el código 01 en lugar de este código 02". Es cierto que, a simple vista, este código 02 parece mucho más complicado. Entonces, ¿por qué alguien preferiría usar este código 02 en lugar del código 01 al implementar sus programas? En realidad, querido lector, no es tan sencillo de explicar utilizando el comando SWITCH en su forma más básica y simple. Sin embargo, puedo asegurarte que el comando SWITCH tiene una ventaja significativa sobre el comando IF en muchas situaciones. Esto se debe a una capacidad que el comando SWITCH tiene y que el comando IF no posee: la de manejar valores diferentes de los que estamos evaluando.

Pero este tipo de situación requiere un uso más avanzado del comando SWITCH. Solo lo he mencionado para que no ignores este comando simplemente porque te parezca confuso y complicado. En realidad, es mucho más útil de lo que parece.

Bien. Veamos este código 02 con un poco más de calma. Aquí puedes observar algunos detalles curiosos en su uso. Primero, ¿qué está haciendo este comando BREAK aquí? ¿No es un comando utilizado dentro de bucles? Exactamente, querido lector. El comando BREAK que ves aquí se utiliza, de hecho, en bucles. Sin embargo, también se usa en algunos momentos dentro del comando SWITCH. Esto nos permite controlar su funcionamiento. En otras palabras, cuando usamos el comando BREAK, le indicamos al compilador que queremos que su ejecución se detenga en ese punto específico dentro de la rutina SWITCH. De esta forma, el compilador sabe exactamente qué hacer. En cierto modo, esto se parece un poco a lo que sucede dentro de un bucle. La diferencia es que hay una separación clara entre las tareas que se van a realizar. No te preocupes, llegaremos a este punto. Pero antes quiero hablar de otra cosa que también puedes observar aquí: las palabras reservadas CASE. Si prestas atención a los códigos 01 y 02, observarás cierta similitud en su estructura.

El comando SWITCH aparece como si fuera un `if`, seguido de un bloque de código. La palabra CASE actúa como el operador de igualdad que se muestra en cada expresión del comando IF en el código 01. A continuación, hay un valor que es exactamente el mismo que el de cada expresión del comando IF. Es interesante, ¿verdad? No es una coincidencia, querido lector. Así es como funciona el comando SWITCH y cómo debe entenderse al usarlo en la práctica. Por esta razón, cuando se observa de manera superficial, el comando SWITCH puede parecer mucho más complicado de lo que realmente es. Pero cuando lo comprendes, se vuelve sencillo y muy interesante. Y pronto empezarás a pensar en nuevas posibilidades.

Sin embargo, en el código 01 tenemos la línea 11, que se ejecutará cuando ningún valor coincida con lo esperado. Lo mismo ocurre aquí con el SWITCH. Para lograr esto, usamos otra palabra reservada: DEFAULT. Dentro de una rutina o bloque SWITCH, esta palabra indica al compilador que, si no se encuentra ningún valor que coincida con el evaluado en la expresión SWITCH, se debe ejecutar una rutina alternativa. Normalmente, lo que se conoce como subcomando DEFAULT se coloca al final del bloque dentro del SWITCH. De este modo, se mantiene la lógica estructural del comando. Sin embargo, no hay ninguna regla que indique dónde debe colocarse. Aunque hacerlo puede resultar algo extraño.

Es muy interesante, ¿no te parece? Ahora bien, hay otro detalle que merece la pena destacar y que aclara aún más la utilidad del comando SWITCH. Este detalle se refiere al siguiente hecho: un comando IF solo ejecutará la rutina correspondiente si el valor de la expresión es verdadero. Sin importar el valor en cuestión, para que la rutina se ejecute, el resultado debe ser verdadero. En el caso del comando SWITCH, la situación es ligeramente diferente. En este caso, el valor de la expresión se evaluará numéricamente. Es decir, lo que realmente importa es si el valor es igual o no al evaluado en la expresión del comando SWITCH. El bloque CASE solo se ejecutará si el valor es igual al especificado en la expresión del comando SWITCH. Sin embargo, el bloque CASE termina con un comando BREAK o al llegar al final del bloque SWITCH. Así que ten cuidado con esto.

Por el momento, incluye siempre un comando BREAK antes de iniciar un nuevo CASE. Esto evitará que tu código sea confuso. En el futuro, exploraremos otras posibilidades en las que no utilizaremos el comando BREAK en ciertas situaciones. Pero, hasta entonces, asegúrate de incluir siempre un comando BREAK antes de cada nuevo CASE.

De acuerdo, en cualquier caso, veamos cómo sería el flujo de ejecución del comando SWITCH. Esto se puede observar claramente en la imagen mostrada a continuación.

Imagen 01

Aquí encontramos algo diferente a lo visto en los demás flujos de ejecución. Esto se debe a que esta imagen 01 demuestra cómo deberías conceptualizar el comando SWITCH. Por lo tanto, si realmente deseas comprender cómo funciona el comando SWITCH en un nivel más avanzado, es importante entender adecuadamente esta imagen. Si logras comprender esta imagen, podrás explorar el comando SWITCH a un nivel más avanzado que el que estamos presentando en este momento.

Pasemos a las explicaciones. Como verás, todo comienza como en cualquier otro comando. Es decir, cuando usamos la palabra reservada para identificar el comando que se va a utilizar. A partir de ese momento y hasta el final, cuando se alcanza el punto de salida, todo lo que sucede pertenece a la rutina dentro del comando SWITCH. Nada de lo que ocurre aquí será visible para ningún otro comando. Comprender esto es crítico para entender algo que exploraremos más adelante en este artículo.

Muy bien, aclarado este punto, lo siguiente es la expresión. Esta expresión debe concebirse en términos numéricos, no lógicos. ¿Qué significa esto en la práctica? Significa que usar condiciones como "mayor que" o "menor que" dentro de la expresión no tendrá el efecto que podrías imaginar. Por lo tanto, no se trata de algo como el comando IF, donde lo que nos interesa es si la expresión es verdadera o falsa. En el caso del SWITCH, la expresión DEBE CONSIDERARSE SIEMPRE COMO UN NÚMERO y el número resultante dependerá del siguiente paso.

El siguiente paso son los comandos CASE. En este punto, la expresión se evaluará de manera lógica. Es decir, se analizará como verdadera o falsa. Pero espera un momento. Ahora estoy confundido. Acabas de decir que la expresión no se analizará como verdadera o falsa, sino como valores numéricos, ¿y ahora dices que se analizará como verdadera o falsa? Amigo, necesitas decidirte, porque así nadie te entiende.

De hecho, querido lector, puede parecer un tanto confuso. Pero no hay otra manera de explicarlo puedes observar, la expresión se compara con varios comandos CASE. Y aquí no hay un orden específico. La expresión y el comando CASE solo se diferencian en que entre ellos existen valores numéricos. Sin embargo, en el momento en que el comando CASE se ejecuta, lo hace evaluando el valor lógicamente, es decir, como verdadero o falso. Precisamente por eso, junto al comando CASE, incluyo otra información: VALUE. Esto es lo que validará el valor de la expresión en relación con el comando CASE y permitirá o no que ROUTINE sea ejecutada. Para habilitar o no la ejecución de algo, necesitamos comparar los valores de manera lógica. Esto hace que explicar cada detalle de este comando sea un poco complicado, ya que muchos podrían imaginar que la evaluación se realiza en la expresión inicial, cuando en realidad ocurre durante el comando CASE.

¿No dije que este comando SWITCH podría resultar confuso si no has comprendido lo explicado en los artículos anteriores? Y eso que aquí estamos trabajando con él en su nivel más básico.

En cualquier caso, cuando el comando CASE verifica que la expresión es igual a VALUE, se ejecutará la ROUTINE. Punto y aparte. Ahora viene la parte que se explicará en otro momento, que es precisamente la línea en rojo de la imagen 01. Esta línea es donde las cosas se complican de verdad. Pero no hablaremos de eso ahora. Vamos a ignorar esa línea roja por ahora. A menos que quieras adelantarte y estudiar lo que sucede cuando el flujo pasa por esa línea, no te metas con ella todavía. Haz exactamente lo que digo ahora: al final del código de ROUTINE, debes colocar un comando BREAK. Al hacer esto, llegaremos finalmente al punto de salida del comando SWITCH. Este comando es divertido, pero puede causar un gran dolor de cabeza a muchos en ciertas situaciones, ya que hay maneras de estructurar el código que lo hacen extremadamente complicado de analizar si no se entienden los comandos de control de flujo.

Muy bien, todo está claro y es maravilloso. Pero tengo una pregunta. En los artículos anteriores vimos que el comando BREAK nos permite salir de un bucle sin que se evalúe su expresión. Eso lo entiendo. Sin embargo, al ver este comando SWITCH junto con el comando BREAK, me quedé un poco confundido respecto a algo. Si estamos dentro de un bucle y usamos el comando BREAK dentro de un SWITCH, como indicaste, ¿no hará eso que el bucle se termine antes de lo previsto? Esa es, sin duda, una excelente pregunta, querido lector. Es una pregunta propia de alguien que realmente está siguiendo y comprendiendo cada uno de los artículos que he publicado hasta ahora sobre este tema. Hagamos lo siguiente: como ya sabemos cómo crear un bucle y controlar internamente su funcionamiento con los comandos BREAK, RETURN y CONTINUE, vamos a hacer algo que lo explique y entienda claramente todo esto.

Para ello, utilizaremos un código un poco más elaborado que los ejemplos mostrados al principio de este artículo y en los artículos anteriores. A continuación se muestra dicho código. Recuerda que el objetivo aquí es puramente didáctico, no crear algo en particular.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " Counting...");
07.     Print(__FUNCTION__, " ", __LINE__, " Pit Stop :: ", Tic_Tac());
08.     switch (Tic_Tac())
09.     {
10.         case true:
11.             Print(__FUNCTION__, " ", __LINE__, " Return TRUE");
12.             break;
13.         case false:
14.             Print(__FUNCTION__, " ", __LINE__, " Return FALSE");
15.             break;
16.     }
17. }
18. //+------------------------------------------------------------------+
19. bool Tic_Tac(void)
20. {
21.     static uchar counter = 10;
22. 
23.     while (true)
24.     {
25.         switch (counter)
26.         {
27.             case 8:
28.                 counter = counter - 1;
29.                 return false;
30.             case 6:
31.                 Print("Press TAB to continue or ESC to abort the count.");
32.                 counter = counter - 1;
33.                 break;
34.             case 5:
35.                 if (TerminalInfoInteger(TERMINAL_KEYSTATE_TAB))
36.                 {
37.                     Print("Accelerating count.");
38.                     counter = 2;
39.                 } else if (TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE))
40.                 {
41.                     Print("General panic...");
42.                     return false;
43.                 }
44.                 continue;
45.             case 0:
46.                 return true;
47.             default:
48.                 counter = counter - 1;
49.         }
50.         Print(__FUNCTION__, " ", __LINE__, " :: ", counter);
51.         Sleep(300);
52.     }
53.     Print(__FUNCTION__, " ", __LINE__, "This line will never be executed.");
54. }
55. //+------------------------------------------------------------------+

Código 03

Este código 03 contiene elementos muy interesantes de construcción e implementación de código. Esto se debe a que aquí utilizamos prácticamente todo lo explicado hasta ahora. Sin embargo, antes de hablar sobre este código, veamos qué ocurre cuando lo ejecutamos en el terminal de MetaTrader 5. De hecho, existen dos posibles resultados, cada uno de los cuales se muestra en una de las animaciones siguientes.

Animación 01

En la animación 01 se puede observar lo que ocurre cuando se presiona la tecla ESC. Al presionar la tecla TAB, veremos algo ligeramente diferente. Esto se muestra en la siguiente animación.

Animación 02

Nota la diferencia muy sutil entre ambas animaciones. Sin embargo, lo que realmente nos interesa es cómo esta información llega al terminal y cómo los comandos de control de flujo determinan cuándo se muestra cada información.

Bueno, querido lector, no entraré en detalles sobre ciertas partes. Quiero que revises y estudies los artículos anteriores para aprender realmente cómo funcionan los comandos de control de flujo. No obstante, daré una explicación general sobre cómo ocurren las cosas en este código 03.

Comencemos por el punto de entrada del código, es decir, OnStart. La línea 6 indica en qué punto se encuentra la ejecución. Esta línea se imprime en el momento en que se ejecuta. Sin embargo, en el caso de la línea 7, las cosas no suceden de inmediato. Esto se debe a que en esta misma línea se hace una llamada a la función Tic_Tac. Por este motivo, la ejecución completa de la línea 7 se pospone hasta que la función Tic_Tac termine sus tareas.

Una vez dentro de la función Tic_Tac, en la línea 19, se entra en un bucle infinito en la línea 23. Pero no te preocupes, querido lector. Aunque este bucle sea infinito, hay puntos en los que podemos salir de él. Presta atención para entender lo que sucede. Observa que en la línea 25 utilizamos un comando de control de flujo, el SWITCH. En cada valor de conteo que nos interese, realizaremos alguna acción. Recuerda que la variable de conteo es de tipo estático. Esto es importante. Así que, cuando el conteo alcance el valor 8, retornaremos al autor de llamada con un valor false. En ese momento, se ejecutará por completo la línea 7. Esto explica por qué aparece el mensaje en la pantalla del terminal Una vez hecho esto, en la línea 8 volveremos a llamar a la función Tic_Tac. Pero esta vez, utilizaremos el retorno de la función como la expresión de un comando SWITCH. De nuevo, la ejecución del comando esperará a que la función Tic_Tac cumpla con sus tareas. A continuación, regresamos a la ejecución del código en la línea 19.

Pero espera un momento, ¿no habíamos salido en la línea 29? ¿No hará que el código repita todo desde el principio, haciendo que terminemos el bucle de la línea 23 exactamente en la línea 29 nuevamente? En realidad, esto podría suceder, querido lector. Sin embargo, debido a que la línea 28 se ejecutó antes de regresar al autor de la llamada, ahora no estamos apuntando al valor ocho, sino al siete. Como no hay ninguna actividad en el comando SWITCH de la línea 25 que haga que la expresión se ejecute con el valor siete, en este caso pasaremos a ejecutar la línea 47. Como la línea 47 solo tiene como tarea ejecutar la línea 48, que reduce el contador en una unidad, ahora estaremos apuntando al valor seis.

De todos modos, después de completar la parte correspondiente al comando SWITCH, ejecutaremos las líneas 50 y 51. Por esta razón, algunos valores no se muestran en el terminal, como el siete. Pero, una vez que imprimimos el valor seis, volveremos al inicio del bucle y ejecutaremos nuevamente el comando SWITCH. Ahora, la expresión tiene el valor seis y, por tanto, tiene un CASE asociado. Presta atención. Cuando se ejecute la línea 31, se imprimirá un nuevo mensaje en el terminal. Luego, en la línea 32, el contador apuntará al valor cinco. Pero, ¿qué ocurre en la línea 33, donde tenemos un comando BREAK? Aquí es donde muchos principiantes se confunden. Esto se debe a que este comando BREAK, como se explicó en un artículo anterior, hace que el bucle en el que se declara termine. Esto es un hecho, y fue demostrado en el artículo donde se explicó este comando. Sin embargo, en este caso específico, esto NO es lo que ocurre aquí. En este caso, el comando SWITCH tiene prioridad sobre cualquier bucle en el que se utilice. Es decir, el comando BREAK se refiere al comando SWITCH y no al bucle en cuestión, sea este WHILE, DO WHILE o FOR.

Sé que esto puede resultar un poco confuso. Pero para demostrar que esto es lo que realmente ocurre, incluí un mensaje en la línea 53 que JAMÁS se imprimirá en este código 03, a pesar de que existe el comando BREAK en la línea 33. Este es el único break presente en todo el código 03.

Bien, creo que esto debería haber quedado claro. Sin embargo, este código estará adjunto para que puedas estudiarlo con calma hasta que comprendas esta pequeña peculiaridad en el uso del comando BREAK.

Así que, cuando se ejecuta el comando BREAK en la línea 33, iremos directamente a la línea 50. Recuerda que el contador se redujo en la línea 32. Por esta razón, el mensaje mostrado indicará que el valor de la variable de conteo es 5.

El bucle se ejecutará nuevamente y se evaluará el comando SWITCH una vez más. Ahora, la expresión apunta al valor cinco. Como existe un CASE asociado a este valor, lo ejecutaremos. Y es aquí donde ocurre algo interesante. Presta atención para comprender lo que sucede en este punto, querido lector. Aquí esperaremos a que el usuario presione una de las teclas mencionadas en el mensaje que se mostró cuando el contador tenía el valor seis. Pero, y este es el punto que debes entender, si el usuario no presiona ninguna tecla, se ejecutará el comando CONTINUE, ubicado en la línea 44. Ahora viene la cuestión. Como este comando CONTINUE siempre está asociado a un bucle, volveremos inmediatamente a la línea 23. Por lo tanto, las líneas 50 y 51 dejarán de ejecutarse mientras el valor de la expresión sea cinco. Cuando el usuario presione una tecla, el flujo se modificará una vez más. En este caso, se ejecutará la línea 38, que hará que el contador cambie al valor dos. En otro caso, se ejecutará el comando de la línea 42. En cualquier caso, en algún momento, ya sea en la línea 42 o en la línea 46, el bucle se finalizará. Sin embargo, en ninguno de estos casos se ejecutará la línea 53. A continuación, regresaremos a la línea 8. En este punto, se evaluará la expresión. Pero tal vez estés pensando: ¿no se supone que SWITCH analiza la expresión de forma numérica? ¿Por qué los valores de CASE son de tipo booleano? Para mí, esto no tiene sentido. Y aquí está el quid de la cuestión, querido lector. Cuando expliqué el comando IF, hablé sobre la conversión de un valor en verdadero o falso. Con respecto al valor falso, no hay cambios. Pero para el valor verdadero, las cosas son un poco diferentes. Esto se debe a que el valor TRUE que puedes ver en la línea 10 es, en realidad, el valor uno. Es decir, si la función Tic_Tac retorna un valor que es cero o uno, este SWITCH de la línea 8 podrá entenderlo y mostrará una de las dos opciones. Sin embargo, si modificas la función Tic_Tac para que retorne otro valor que NO SEA cero o uno, este SWITCH de la línea 8 no encontrará ninguna correspondencia asociada al valor retornado. En ese caso, no se mostrará ningún mensaje.

Sin embargo, es importante destacar el siguiente hecho. Si en lugar de este SWITCH de la línea ocho utilizas un comando IF, podría mostrarse algún mensaje. Esto dependerá de cómo implementes el comando `if`. Como el objetivo aquí es que empieces a pensar como un programador, no te mostraré cómo deberías proceder en este caso. Solo menciono estos hechos para que comiences a razonar como un programador y procures entender qué hace realmente cada comando, así como sus capacidades y limitaciones en el control de flujo.

Consideraciones finales

En este artículo vimos cómo funciona el comando SWITCH. Sé que, al principio, puede parecer más una fuente de confusión que una herramienta para facilitar la programación e implementación de soluciones, pero te aseguro que con práctica se convierte en una herramienta muy útil. Pero quiero recalcar una vez más: estudia cada comando poco a poco. Intenta realizar las mismas tareas, pero de formas ligeramente diferentes. Así entenderás cómo cada pieza se va ensamblando gradualmente.

Empieza poco a poco, sin prisa por crear un indicador o incluso un Asesor Experto. Construye una base sólida de conocimientos antes de adentrarte en cosas más complejas. Así, tu trabajo será mucho más sencillo y tus esfuerzos serán mejor recompensados. Aprovecha para estudiar los códigos que encontrarás adjuntos y nos vemos en el próximo artículo.