Del básico al intermedio: Variables (I)

Introducción

El contenido expuesto aquí tiene como objetivo, pura y simplemente, la didáctica. En ningún caso debe considerarse como una aplicación final, donde el objetivo no sea el estudio de los conceptos aquí mostrados.

Aquí vamos a comenzar un estilo de artículo cuyo objetivo es ayudar y explicar ciertos conceptos y la utilización de MQL5 para diversas actividades. No está únicamente enfocado en crear indicadores, scripts o incluso Expert Advisors. El propósito principal aquí es transmitir y divulgar conocimiento.

Muchos de ustedes ya me conocen de otros artículos que he publicado. Sin embargo, como aquellos artículos están orientados a programadores con alguna experiencia, y muchos han demostrado interés en comenzar a estudiar de manera más seria el tema, me ha parecido válido crear otro perfil para dar algunas explicaciones básicas sobre este asunto. Esto no significa que trataremos temas que muchos ya conocen, volviendo los artículos aburridos y sin propósito. Al contrario, intentaré traer artículos que sean realmente interesantes y entretenidos. Pero como ya existe una gran cantidad de artículos en el otro perfil, esperando únicamente ser publicados, y con el interés de compartir un poco más de mi conocimiento con todos, alimentaré este perfil con nuevos artículos. Los temas aquí estarán enfocados en avanzar desde lo básico hasta lo que considero un nivel intermedio. Sin embargo, exploraremos diversas cosas dentro de MQL5, y algunos de estos conceptos también serán útiles para quienes pretendan estudiar otros lenguajes de programación.

Así que, en este primer artículo, comenzaremos con la parte más básica y fundamental presente en la programación en general. El tema será: Variables. Pero como me gusta separar adecuadamente las cosas, iniciaremos un nuevo tema para comenzar realmente el artículo.

Variables. La base de la programación

Mucha gente cree, de manera errónea, que los programas de computadora se crean sobre funciones y procedimientos. Sin embargo, este tipo de idea es un error. Los programas de computadora se crean y se conciben teniendo como base, fundamentalmente, las variables. Ningún programa, por más elaborado que sea, se crea o se propone con otro objetivo. El propósito siempre es hacer que una variable pueda ser conocida y utilizada.

Puede parecer extraño decir esto, sobre todo cuando en cursos y libros todos buscan enfocarse en funciones y procedimientos, dando a entender que estos son los principios básicos de la programación. Sin embargo, no estoy aquí para generar polémica o controversia. Estoy aquí para aportar. Dicho esto, a pesar de que estos términos conocidos como funciones y procedimientos son de gran importancia, no son más que algún tipo de variable que está siendo calculada. Esto quedará más claro a lo largo de los próximos artículos.

Sin embargo, en este artículo, el objetivo es presentarte a ti, querido lector, el concepto de variables. Y sí, existen diferencias entre tipos de variables. Saber qué representa cada tipo y cómo podemos hacer el mejor uso de cada una es la diferencia entre un programa bien escrito y un simple programa que realiza una determinada tarea.

Para comenzar, existen dos tipos diferentes de variables: las que pueden cambiar de valor y las que no pueden cambiar de valor. En este segundo caso, lo más correcto es llamar a este tipo constante. Sin embargo, dado que los programas de computadora, al ejecutarse en modo usuario, siempre estarán presentes en la memoria RAM, la palabra constante no es tan adecuada. Esto se debe a que, por el simple hecho de que el valor está en RAM, puede ser modificado de alguna manera. ¿Quién nunca ha usado un CRACK para sortear alguna limitación? Pues bien, en muchos casos, el CRACK actúa directamente sobre alguna parte del ejecutable, ya sea cuando está en la memoria RAM o cuando aún está en el disco.

Cuando la intervención se realiza en el disco, el CRACK actúa directamente sobre constantes. Esto se debe a que los valores presentes en el disco no cambian con el paso del tiempo. Tienden a permanecer inalterados. De esta manera, el CRACK está actuando, de hecho, sobre un valor que parece ser constante. Sin embargo, es variable precisamente porque el CRACK logra modificarlo. No obstante, cuando se trata de la memoria RAM, algunas partes pueden ser tratadas como constantes, que el intento de modificar dichos valores será considerado un error. El procesador notificará al sistema operativo para que tome las medidas necesarias. Por lo tanto, este es el primer punto a observar: las variables pueden ser constantes o no. Si los valores están en RAM, nuestra aplicación puede determinar qué será constante y qué será variable. En cualquier otro escenario, las variables nunca deberán considerarse como constantes.

Muy bien, hecha esta pequeña diferenciación, aunque sea solo de manera conceptual, podemos pasar a la siguiente etapa, donde este mismo concepto será puesto en práctica. Así que vamos a comenzar con calma. Esto se debe a que ciertos conceptos son un tanto difíciles de separar, lo que al principio puede hacer que todo parezca bastante complicado de entender. Pero ten paciencia, querido lector. Pronto te sentirás más seguro y confiado, y serás capaz de hacer diversas cosas con mucha más facilidad. Solo es cuestión de ir estudiando las cosas poco a poco, empezando por lo que se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     int     value1;
07.     char    value2;
08.     long    value3;
09. 
10.     value1 = 10;
11.     value2 = 5;
12.     Print("Result: ", value1 + value2 + value3);
13. }
14. //+------------------------------------------------------------------+

Código 01

Este código 01 es muy simple y básico. Aquí tenemos tres declaraciones de variables, que se encuentran en las líneas 06, 07 y 08. Por ahora, no te preocupes por la cuestión de los tipos. Esto lo abordaremos con más calma en otro artículo. De momento, presta atención únicamente a lo que será explicado. A pesar de que tenemos tres variables declaradas, dos de ellas, en realidad, son constantes temporales, y la otra no está siendo referenciada o inicializada, como es el término correcto que se utiliza aquí. Muchas veces, podrías pensar que este código producirá un cierto resultado, pero el hecho de no entender cómo funcionan las cosas, o ignorarlas, puede poner todo tu trabajo en riesgo.

Para comprender esto, veamos las salidas que produce el compilador. En caso de que estés utilizando MetaEditor, la salida se parecerá a la imagen 01, que se muestra a continuación.

Imagen 01

En mi caso, utilizo otra herramienta para editar los códigos, aunque esta también utiliza el compilador de MetaTrader 5 para crear las aplicaciones. El resultado es como el mostrado más abajo.

Imagen 02

Observa que, en ambos casos, el compilador nos está generando una advertencia, y debes tener cuidado cuando estos avisos sean emitidos. Esto se debe a que, en muchos casos, indicará que tu aplicación podría funcionar de una manera no esperada. Cuando ocurra que muestre algún detalle relacionado con la salida del compilador, lo haré conforme al modelo que se muestra en la imagen 02. Sin embargo, el resultado será muy parecido a los mensajes que verás si estás utilizando MetaEditor. Así que solo presta un poco de atención y podrás seguir cada uno de los artículos sin dificultad.

Muy bien, ahora supongamos que ignores esta advertencia del compilador. Algunas pueden ser ignoradas, mientras que otras NO. Y decides ejecutar esta aplicación, ya compilada en MetaTrader 5. ¿Qué tipo de resultado esperas obtener? Bien, obviamente esperas conseguir el valor 15, ya que en la línea 10 estamos diciendo que la variable value1 es igual a diez y en la línea 11 que la variable value2 es igual a cinco. Así, cuando la línea 12 sea ejecutada, el resultado esperado es la suma de estos dos valores. ¿Correcto? Bien, veamos. El resultado se muestra a continuación.

Imagen 03

¡Vaya! ¿Pero qué pasó aquí? ¡¿Estás bromeando?! No, querido lector, esto no es ninguna broma. Es un hecho que puedes comprobar por ti mismo. Pero tu asombro no es para nada extraño, ya que claramente esperabas que el valor impreso fuera igual a 15. Entonces, ¿por qué se genera este valor cero? El motivo es precisamente la variable value3. Al participar en el cálculo y NO HABER SIDO debidamente inicializada, puede contener cualquier valor. Y dependiendo de ese valor, que en programación llamamos “basura”, hará que el resultado final sea incorrecto.

Bien, en este caso tenemos dos alternativas. La primera es inicializar el valor de value3 correctamente. La segunda es eliminar value3 del cálculo que se está realizando en la línea 12. Como nuestro objetivo en este momento es generar el resultado 15, la segunda alternativa es la que emplearemos. De esta manera, el mismo código 01 tendrá su línea 12 modificada de la siguiente forma, como puedes observar más abajo.

Print("Result: ", value1 + value2);

En este caso, cuando intentes compilar el código, el compilador generará el siguiente tipo de advertencia.

Imagen 04

Observa que la advertencia es diferente a la que vimos anteriormente. Entonces, después de analizarla, decides que en este caso en particular puede ser ignorada. Ejecutas la aplicación en MetaTrader 5 y obtienes el resultado que se muestra a continuación.

Imagen 05

¡Éxito! Hemos conseguido exactamente lo esperado. Ahora, volvamos al código 01 original para comprender algunos conceptos básicos. Como se mencionó anteriormente, las variables value1 y value2 son, y deben ser pensadas, como constantes temporales. ¿Pero por qué? El motivo es precisamente el hecho de que NO cambian de valor durante todo el código. Permanecen con el mismo valor todo el tiempo. Sin embargo, hay una cuestión aquí, y es en este punto donde las cosas comienzan a ponerse un poco más interesantes.

A pesar de que value1 y value2, así como value3, son variables, tú, como programador, puedes cambiar esto. De esta manera, garantizas que un valor asignado a una determinada variable NO CAMBIARÁ, independientemente de algún descuido que puedas cometer durante el proceso de codificación. Muchos programadores más experimentados que trabajan con códigos más elaborados y complejos prefieren usar lenguajes que permiten este tipo de control. En estos casos, tú, como programador, puedes decir: "Mira, compilador, esta variable aquí no debe ser vista como una variable. Quiero que sea una constante". Y el compilador te ayudará a garantizar que dicha variable se mantenga como una constante. Para lograr este tipo de control en MQL5, hacemos uso de una palabra reservada. Así, un código cuyo resultado será el mismo que el obtenido anteriormente podría escribirse de otra manera. Pero antes de ver esto aplicado en la práctica, veamos otra cosa. Esto nos lleva a crear el código que se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const int   value1;
07.     char        value2;
08. 
09.     value1 = 10;
10.     value2 = 5;
11.     Print("Result: ", value1 + value2);
12. }
13. //+------------------------------------------------------------------+

Código 02

Si intentas compilar este código 02, el compilador te lo impedirá debido a los errores que se muestran más abajo.

Imagen 06

En este caso, puedes notar que estamos enfrentando dos errores: uno generado en la línea seis y otro en la línea nueve. Ahora, entendamos qué significa cada error, ya que lo más importante no es simplemente corregirlos, sino comprender lo que nos están indicando. Esto se debe a que no siempre un error es un error en sí mismo. Muchas veces, puede ser una simple advertencia del compilador que nos indica que estamos intentando hacer algo que no debería hacerse. Este es precisamente el caso del error señalado en la línea nueve.

Presta atención, porque esto puede ayudarte bastante en la programación con MQL5. Cuando defines una variable como una constante, cualquier intento de cambiar su valor durante la ejecución del código será considerado un error GRAVE. Sin embargo, aún no estamos ejecutando nuestra aplicación. A pesar de esto, el compilador de MQL5 ya nos está alertando sobre la posibilidad de que ocurra un error grave durante la ejecución. Por esta razón, impide que el código 02 sea compilado. Esto sucede porque tú, como programador, le dijiste al compilador que la variable value1 NO es una variable, sino una CONSTANTE. Y lo hiciste utilizando la palabra const antes de la declaración, como puedes observar en la línea seis del código 02. Muchos programadores con menos experiencia optarían por eliminar la palabra const de la declaración en la línea seis. Esto no sería un error en sí mismo, pero al hacerlo, perderías la ayuda del compilador para evitar que la variable value1 sea tratada como una constante. Esto podría ocasionar otros problemas en tu aplicación, como la generación de valores incorrectos en determinados momentos, sin comprender realmente por qué el código no se está comportando de la manera esperada.

Pero aquí entra otra cuestión, y esta es precisamente la que origina el error en la línea seis, como puedes observar en la imagen 06. Esta misma cuestión es la que hacía que el código 01 generara un valor incorrecto durante la ejecución cuando la variable value3 era utilizada en el cálculo de la línea 12, refiriéndonos al código 01.

La cuestión en sí es, precisamente, la inicialización de valores. Algunos lenguajes de programación inicializan los valores de las variables, normalmente con un valor predeterminado que es cero. Sin embargo, al hacerlo, los desarrolladores del compilador deben tener ciertos cuidados, como evitar que las variables que serán tratadas como constantes no tengan un valor definido de manera explícita. El hecho de simplemente asignar arbitraria e implícitamente el valor cero a toda variable no inicializada podría ser perjudicial para la aplicación final. Esto ocurre precisamente por el detalle mostrado en el código 02, donde, si el compilador asignara automáticamente el valor cero a toda variable no inicializada, el resultado de la operación en la línea 11 sería completamente incorrecto. Y tú, como programador, perderías mucho tiempo intentando entender el motivo. Por lo tanto, no siempre un error es, de hecho, un error. Del mismo modo, un aviso del compilador no siempre necesita ser corregido. En algunos casos, podemos ignorar ciertos detalles que nos son reportados.

Muy bien, habiendo aclarado esto, ¿cómo debería escribirse entonces el código 02 para que pudiera ser compilado? Pues bien, querido lector, teniendo en cuenta que realmente queremos las cosas de esa manera, el código debería ser modificado como se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const int   value1 = 10;
07.     char        value2;
08. 
09.     value2 = 5;
10.     Print("Result: ", value1 + value2);
11. }
12. //+------------------------------------------------------------------+

Código 03

Ahora sí. Este código 03 será, efectivamente, compilado, y el resultado será el mismo que puede verse en la imagen 05. Sin embargo, quizás haya surgido una duda en tu mente: ¿por qué programar algo de esta manera hasta ahora mostrada? ¿No sería más sencillo y fácil usar algo como lo que se muestra a continuación?

1. #property copyright "Daniel Jose"
2. //+------------------------------------------------------------------+
3. void OnStart(void)
4. {
5.     Print("Result: ", 10 + 5);
6. }
7. //+------------------------------------------------------------------+

Código 04

Sí, querido lector, en algunos casos, programar algo como lo mostrado en el código 04 es, de hecho, la manera más simple, dado que estamos lidiando exclusivamente con constantes. Sin embargo, no siempre este tipo de enfoque es deseable. Esto se debe a que las constantes numéricas son “frías” y no nos transmiten información sobre el motivo de su existencia. Al observar este código 04, ¿serías capaz de decir cuál es la razón por la que se utilizan los valores diez y cinco? Tal vez estés realizando algún tipo de factorización para descubrir un resultado inicialmente desconocido. De acuerdo, si este fuera el motivo, estarías haciendo uso de otro tipo de variable, una que será explicada en detalle en otro artículo. Sin embargo, si este no fuera el caso, con el tiempo te preguntarías por qué se está realizando ese cálculo, y al hacerlo podrías terminar teniendo dificultades para entender tu propio código.

Precisamente por este motivo, muchos programadores en todo el mundo hacen uso de ciertos recursos del lenguaje que están utilizando. En el caso en cuestión, donde estamos empezando a hablar sobre el tema y, por ende, explicando cómo programar de una manera más eficiente, el uso de variables es la mejor elección en este momento. Esto se debe a que puedes asignarles un nombre adecuado y, aun después de mucho tiempo, serás capaz de comprender el propósito de ese valor, incluso si la variable ha sido implementada como una constante.

Creo que este primer punto ha quedado debidamente aclarado, de modo que tú, querido lector, puedas entender por qué en algunos momentos decimos que una variable es una constante y en otros no, así como lo que este tipo de declaración hará con nuestras queridas variables. Como aún tenemos espacio para hablar un poco más sobre el tema, pasemos a otro aspecto, aunque siempre manteniéndonos dentro de los conceptos básicos sobre variables.

Vida útil y visibilidad

Una cuestión que suele confundir a muchas personas, incluso a aquellas con buena experiencia en programación, es el tiempo de vida de las variables, así como también su visibilidad. No obstante, aunque parecen temas distintos, ambos pueden tratarse juntos, ya que tanto el tiempo de vida como la visibilidad están, de cierta forma, correlacionados. La visibilidad es un tema mucho más amplio y será explicado con más detalle en otros artículos a lo largo del tiempo, ya que existen cuestiones relacionadas con la visibilidad que afectan enormemente la manera en que una aplicación debe ser diseñada. Pero eso será tratado en un momento oportuno.

Por ahora, nos mantendremos en la parte más básica de todas: es decir, cuándo “nace” una variable, dónde “muere” y si existe alguna forma de evitar que “muera”.

Para no complicar las cosas inicialmente, hagamos algunas consideraciones. La primera y más simple es la siguiente:

Una variable “nace” en el momento de su declaración.

Esta frase parece obvia, pero las cosas empiezan a volverse un poco más confusas cuando observamos esto desde la perspectiva de la visibilidad de una variable determinada. Sin embargo, antes de profundizar más en esto, veamos un caso sencillo. Para ello, utilizaremos el código que se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const int value1 = 10;
07.     int value2;
08. 
09.     value2 = 5;
10.     {
11.         int value2;
12. 
13.         value2 = 8;
14. 
15.         Print("Result #01: ", value1 + value2);
16.     }
17.     Print("Result #02: ", value1 + value2);
18. }
19. //+------------------------------------------------------------------+

Código 05

Antes de ejecutar este código 05, querido lector, ¿podrías responder cuál será el valor que se imprimirá en el terminal cuando se ejecuten las líneas 15 y 17? ¿O acaso este código ni siquiera será compilado? Bien, antes de que empieces a tener dudas sobre esto, sí, este código será compilado y ejecutado. Sin embargo, hay una cuestión que debes entender aquí. Esta es la primera de varias que necesitarás comprender a lo largo de esta jornada.

Cuando el código 05 sea ejecutado, verás el resultado que se muestra en la imagen a continuación.

Imagen 07

Ahora te vuelvo a preguntar: ¿puedes entender estos resultados? Bien, esto es solo una pequeña demostración de lo que realmente podemos hacer. Muchos programadores, incluso con bastante experiencia, evitan asignar nombres iguales a variables dentro de un mismo bloque de código. Pero aquí no estamos usando un solo bloque de código, sino dos. ¿Cómo es eso? ¿Te has vuelto loco o estás soñando despierto al decir que tenemos dos bloques de código aquí en el código 05? No, querido lector, a pesar de la edad, aún no he perdido la cordura. El detalle es que ya estoy introduciendo un tema que entenderás mejor en otro momento. Pero en MQL5, así como en otros lenguajes basados en C y C++, cada bloque de código se inicia con una llave de apertura `{` y finaliza con una llave de cierre `}`.

Cualquier cosa que esté entre estos dos símbolos es, y debe ser considerada, un bloque de código. Existen otras formas de definir un bloque de código, como en el caso de los bucles. Sin embargo, esta, utilizando las llaves, es la más sencilla de entender. Así que, en este código, un bloque comienza en la línea cinco y termina en la línea dieciocho. El otro bloque comienza en la línea diez y finaliza en la línea dieciséis. Comprendido esto, vamos a resolver dos temas de una sola vez.

El primero es el hecho de que una variable declarada dentro del código inicia su “vida” en el momento de su declaración y finaliza su “vida” en el momento en que el bloque al que pertenece deja de existir. Existe una excepción a esto, pero no te preocupes por ella en este momento. Simplemente trata de entender este concepto más sencillo con el que estamos trabajando ahora. El segundo hecho es que cualquier cosa declarada fuera de un bloque será considerada global dentro del bloque al que pertenece.

Este segundo aspecto es un poco más complicado de entender de inmediato, pero vamos paso a paso. Primero, vamos comprender por qué el código 05 nos genera el resultado que se observa en la imagen 07. Basándonos en las declaraciones mencionadas anteriormente, podemos ver que en las líneas siete y once se está declarando una variable con el mismo nombre. Y en las líneas nueve y trece, estamos asignando valores diferentes a una variable que, en teoría, parece ser la misma. Sin embargo, si prestas atención al código, notarás que están en bloques diferentes: una está en un bloque y la otra en un bloque interno al primero.

De manera bastante simple, el bloque donde declaramos value2 en la línea siete es un bloque global. Por lo tanto, la value2 que se está declarando en la línea siete ES UNA VARIABLE GLOBAL. En cambio, la variable value2 declarada en la línea once es una variable local. Si miramos desde fuera del bloque, esta variable en la línea once es local; pero dentro del bloque que comienza en la línea diez, dicha variable declarada en la línea once es considerada global dentro de ese contexto.

Sé que esto puede ser algo confuso, así que detente un momento y reflexiona sobre ello. Entender este concepto es EXTREMADAMENTE IMPORTANTE, porque no estás obligado a usar nombres diferentes todo el tiempo. El compilador exige que utilices nombres diferentes para variables dentro del mismo bloque, pero si las variables están en bloques diferentes, el compilador aceptará que tengan el mismo nombre, aunque se trate de variables distintas.

Entonces, ¿por qué obtenemos dos valores diferentes en el resultado final? La razón es simple, querido lector: la variable local tendrá prioridad sobre la variable global cuando ambas tengan el mismo nombre, independientemente del tipo de variable. Si el nombre es idéntico, el compilador preferirá utilizar la variable local. Sin embargo, debes tener cuidado, ya que algunas otras lenguajes podrían usar una metodología diferente. Lo que estoy explicando aquí se aplica específicamente a MQL5, dado que nuestro enfoque está precisamente en este lenguaje en particular.

Con esto, es sencillo entender el siguiente hecho: cuando en la línea trece decimos que value2 es igual a 8, esto no destruirá el valor que value2 tiene en el ámbito global, que es 5 y fue definido en la línea nueve. Por esta razón, cuando usamos la línea 15 para imprimir el resultado de value1 sumado con value2, obtenemos dieciocho en el primer caso. Y cuando la línea 17 realiza el mismo cálculo, el resultado es quince.

Sin embargo, si intentas hacer algo similar utilizando un código como el que se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const int value1 = 10;
07.     int value2;
08. 
09.     value2 = 5;
10. 
11.         int value2;
12. 
13.         value2 = 8;
14. 
15.         Print("Result #01: ", value1 + value2);
16. 
17.     Print("Result #02: ", value1 + value2);
18. }
19. //+------------------------------------------------------------------+

Código 06

El compilador se quejará y te mostrará algo similar a lo que se observa en la imagen 08, justo abajo.

Imagen 08

Esto se debe a que, a diferencia del código 05, este código 06 cuenta con un único bloque, que comienza en la línea cinco y termina en la línea dieciocho. Por lo tanto, ten cuidado cuando estés programando o intentando entender lo que otro programador ha escrito, y por qué tus intentos de modificar el código no han tenido éxito.

Sin embargo, puede que te enfrentes a una situación un poco diferente. Esto puede observarse en el código que se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int value2;
05. //+------------------------------------------------------------------+
06. void OnStart(void)
07. {
08.     const int value1 = 10;
09. 
10.     value2 = 5;
11. 
12.         int value2;
13. 
14.         value2 = 8;
15. 
16.         Print("Result #01: ", value1 + value2);
17. 
18.     Print("Result #02: ", value1 + value2);
19. }
20. //+------------------------------------------------------------------+

Código 07

En este caso, el compilador te mostrará un mensaje muy similar al que puedes ver en la imagen 09, justo a continuación.

Imagen 09

Bien, al observar este mensaje presente en la imagen 09, ¿qué acción deberías tomar con respecto al código 07 si tu objetivo es obtener un resultado igual al de la imagen 07? Querido lector, este es un punto donde las cosas realmente se vuelven extremadamente complicadas. La razón es que la declaración de value2, realizada en la línea cuatro, solo “morirá” cuando la aplicación deje de existir o deje de ejecutarse. Por este motivo, en este tipo de escenario, NO DEBEMOS usar variables con alcance local junto con otras del mismo nombre que tengan alcance global.

Como regla general, las variables o valores globales son un problema en sí mismos, algo que deberías evitar a toda costa. Es cierto que no siempre será posible hacerlo, pero si este tipo de situación ocurre o no hay otra alternativa, debes usar nombres diferentes para las variables. Muchos programadores, entre los que me incluyo, suelen añadir un prefijo o sufijo con el fin de distinguir entre variables globales, que existirán durante toda la vida del programa, y variables locales o incluso globales que pertenecen a un bloque específico.

Consideraciones finales

Este ha sido el primer artículo en el que mi enfoque ha sido explicarte, ya seas principiante o un programador casual, cómo trabajar de una manera más adecuada y productiva utilizando MQL5. El objetivo aquí es, única y exclusivamente, transmitirte un poco de mi experiencia como programador profesional, mostrándote cómo proceder para crear tus propios códigos de manera simple, eficiente y sin mayores inconvenientes.

La programación es algo memorable y maravilloso. Si se aborda correctamente y con un conocimiento construido de forma sólida y consistente, sin duda te traerá buenos resultados en el futuro. Así que, en el próximo artículo, continuaremos tratando el tema de las variables, ya que aquí solo presenté cuál será la metodología que utilizaremos en los próximos textos. Espero que te haya gustado. Y si deseas ver un material un poco más avanzado, pero con una metodología similar, puedes consultar mis otros artículos disponibles en esta comunidad, aunque en otro perfil.