Lenguaje MQL4 para iniciados. Introducción

Introducción

La serie de artículos está destinada a los operadores que no tienen conocimientos de programación pero desea aprender el lenguaje MQL4 lo más rápido posible en el menor tiempo y con el menor esfuerzo posible. Si le dan miedo frases como "orientación a objetos" o "matrices tridimensionales", este el artículo que necesita. Las lecciones están diseñadas para obtener rápidamente los máximos resultados. Además, la información se proporciona de forma comprensible. No debemos profundizar en la teoría, sino que obtendrá los beneficios prácticos ya desde la primera lección.

Consejo

Si no ha programado nunca antes, puede que encuentre alguna dificultad para entender el significado de algunos casos durante la primera lectura. Lea detenidamente el texto una vez más y piense cada frase. Al final comprenderá todo, ya que en realidad no hay nada difícil. No siga adelante sin comprender la información previa. Estudie los ejemplos del código. Escriba sus propios ejemplos en base a lo que ya ha entendido.

Primera toma de contacto con MQL4

En primer lugar, vamos a ver qué puede hacer usando este lenguaje. Tiene por finalidad la creación de scripts, indicadores personalizados, asesores expertos y bibliotecas:

• Los scripts son secuencias de comandos y programas que funcionan solo cuando se lo solicitamos. Pueden sustituir a las operaciones que realizamos en el trading cada día. Por ejemplo, cuando abrimos órdenes de compra. También pueden realizar funciones específicas: por ejemplo, analizar los gráficos y generar información estadística.
• Los indicadores personalizados son indicadores técnicos escritos además de los indicadores integrados. Estos crean gráficos y otro tipo de información visual. A diferencia de los scripts, los indicadores personalizados operan con cada cambio del precio, es decir, a cada tick. Qué indicadores se mostrarán, dependen solo de nosotros. Puede ser un gráfico senoidal inútil o algo que nos ayude a orientarnos en la situación del mercado. Por ejemplo, si sabemos exactamente en qué circunstancias experimenta el mercado una tendencia y cuando es plano, podemos escribir esto como un indicador.
• Los asesores expertos son sistemas de trading mecánicos vinculados a cualquier instrumento financiero. Al igual que los indicadores personalizados, los asesores expertos operan en cada tick, pero a diferencia de aquellos, estos pueden informarnos sobre la situación del mercado (por ejemplo, proporcionar cierta orientación sobre la compra o la venta) u operar por sí mismos sin nuestra ayuda. Un terminal ayuda a probar las estrategias, lo que permite realizar una rápida evaluación de la rentabilidad de nuestro asesor experto. Podemos describir nuestra estrategia en el lenguaje MQL4, mientras que un terminal sigue sin más todas nuestras instrucciones.
• Las bibliotecas son conjuntos de funciones para realizar tareas específicas. Por ejemplo, uno de nuestros asesores puede usar funciones matemáticas especiales para decidir cuándo comprar y cuándo vender.

En este artículo aprenderemos a escribir scripts comunes. Para este propósito se utiliza un programa especial: MetaEditor 4. Para iniciarlo, pulsamos la tecla F4 en un terminal personal abierto. Para crear un nuevo script hacemos clic en File->New en el menú de MetaEditor 4 o usamos los botones Ctrl+N:

En la ventana que aparece elegimos lo que vamos a crear. Elegimos Script y hacemos clic en Next:

En la siguiente ventana introducimos el nombre del script en el campo Name. Añadimos nuestro nombre en el campo Author y el correo electrónico o dirección web en el campo Link. Luego hacemos clic en OK:

Después de esto veremos una nueva ventana con la que trabajaremos principalmente. Esta muestra el texto original:

Recuerde que incluso un script vacío e inoperativo contiene código. Ahora, todo está listo para comenzar a programar. Pero, por desgracia, no tenemos ni idea sobre cómo debe hacerse. Vamos a intentar mejorar la situación.

Código fuente, compilación y otros

Debemos conocer una cuestión importante. Lo que se escribe en MetaEditor 4 es código fuente. Es decir, una secuencia de comandos que seguirá un terminal uno después de otro en sentido descendente. Pero el terminal no puede seguir el código fuente. El código fuente solo es comprensible para nosotros, no para MetaTrader. Para hacer que el código fuente sea comprensible para el terminal, este debe ser "traducido" a un "lenguaje" adecuado. Para hacer esto, pulsamos la tecla F5 en MetaEditor. Después de esto, se compilará el código fuente y se obtendrá un archivo ejecutable.La compilación es un proceso de "traducción de un código fuente, escrito y comprensible por nosotros, en un archivo especial que puede ser reconocido y ejecutado por MetaTrader. Compruébelo usted mismo. Cree un nuevo script llamado "Test1" y guárdelo, pero no lo compile. Abra el terminal y, usando "navigator", entre en la carpeta "Scripts". Verá que no hay ningún script llamado "Test1":

Ahora compile el script (tecla F5):

Entre en el terminal una vez más: Hay un script llamado "Test1":

Hago doble clic en el nombre del script en el terminal Navigator y este se abrirá. Pero no ocurre nada, ya que el script está vacío.

Debe ya saber cómo es el proceso de escritura del script: escribimos el código fuente, lo compilamos, abrimos el script en el terminal, observamos el resultado, cambiamos el código, compilamos, observamos... y así sucesivamente hasta que obtenemos el resultado necesario.

¿Dónde deben escribirse los scripts?

Ya ha visto que un script vacío contiene un código específico. Pero ¿dónde debemos escribir el código fuente que tiene que funcionar? Debe escribirse entre las líneas start(){ y return(0);}, como se muestra en la imagen:

Escriba aquí todo lo que le indico y todo esto funcionará. Más tarde veremos en detalle lo que significan estas líneas.

Variables

¿Qué es una variable? Intente responder a esta pregunta usted mismo y yo le ayudaré. ¿Qué edad tiene? ¿Qué edad tendrá dentro de cinco años? Ahora mire: su edad es una variable. Su edad cambia con el paso del tiempo, como cualquier otra variable. Es decir, la primera característica de una variable es su cambio con el paso del tiempo. Otro ejemplo: ¿cuál era su altura cuando tenía cinco años? Probablemente mucho menor que ahora. La altura es otro ejemplo de una variable. Pero hay una importante diferencia. Recuerde que la edad se calcula en enteros. La altura se mide mejor con decimales ("número de coma flotante"). Edad: 20 años, 30 años. Altura: 1,8 metros, 1,95 metros. Esta característica es muy importante: cada variable es de un tipo concreto. Veamos qué otros tipos de variables existen. Podemos describir en cifras muchos parámetros, pero ¿cómo describiríamos un texto? Para esta finalidad se utiliza el tipo string (cadena de caracteres). Dicho tipo de variables contiene solo líneas. Ahora veamos cómo crear y describir una variable en el lenguaje MQL4. Ejemplo:

int age = 25;

Aquí vemos una variable de tipo entero (int: entero). Int es una palabra clave en el lenguaje MQL4 que indica que usamos un tipo de número entero. Luego escribimos "edad", que es el nombre de la variable, es decir una palabra con cuyo uso tendremos acceso al significado almacenado en esta variable. Después de esto asignamos el valor 25 a la variable usando el símbolo "=". Después de cada instrucción debe ponerse ";". Recuerde que la declaración e inicialización de cualquier variable tiene la siguiente forma para dicha variable:

[ tipo de variable] [ nombre de la variable] = [ valor de la variable];

Por cierto, no es necesario asignar un valor a una variable (inicializarla), puede escribirlo:

int age;

Un ejemplo más:

double height = 1.95;

Aquí declaramos una variable llamada "height", que almacena los valores de tipo double (número de coma flotante y decimales) y asignamos un valor 1,95 usando el operador "=".

Ahora veamos una variable string:

string name = "Janet";

string es un tipo de variable, el nombre es el nombre de la variable y "Janet" es el valor de la variable. Recuerde que el valor de la variable de tipo string se coloca entre las comillas dobles (").

Hay otro tipo de variable muy útil: bool (booleana). Las variables de este tipo solo pueden aceptar dos valores: verdadero o falso. Ejemplo:

bool trend = false;

Ahora debe recordar algunas cosas sencillas. El lenguaje MQL4 es un tipo de lenguaje formal, es decir, es muy importante si escribimos código en MAYÚSCULAS o en minúsculas. Por ejemplo, si declaramos varias variables con nombres idénticos pero con diferente caso, tendremos variables completamente distintas:

double HIGHTPRICE;
double hightprice; 
double HightPrice; 
double hightPrice;

El código mostrado anteriormente creará cuatro variables completamente distintas. Recuerde también que todas las palabras clave del lenguaje MQL4 se escriben en minúsculas.

Ejemplo siguiente:

DOUBLE hightPrice1;
Double hightPrice2;

El código anterior no funcionará, ya que la palabra "double" no será aceptada como palabra clave del lenguaje MQL4. Un aspecto importante más es que los nombres de las variables no pueden comenzar con números ni símbolos especiales (*,&,,%,$). Por ejemplo:

double 1price;
double %price;

Un elemento más del lenguaje es el comentario. Si escribimos "//" antes de una línea, esta será un comentario en su totalidad. Esto significa que durante la compilación esta línea será ignorada. Por ejemplo:

// this is a comment 

Ahora puede ver que el código de un script vacío incluye muchos comentarios de carácter informativo. Comente su código. Algunas veces puede ayudarle a ahorrar mucho tiempo.

Trabajo con variables

Veamos ahora qué podemos hacer con las variables una vez que las hemos declarado. Veamos un ejemplo muy simple:

double a = 50.0;// declare a value with a floating point and
                // assign the value 50 to it
double b = 2.0; 
double c;   

c = a + b;      // assign to the variable c sum of variables
                // a and b. Now the value is equal to 52. Like after
                // any other instruction put a semicolon (“;”) 

c = a - b;      // diminution, c = 48 
c = a*b;        // multiplication, c = 100 
c = a / b;      // division, c = 25   
c = (a + b)*a;  // place the operations that should be performed
                // first inside the brackets. In our case 
                // first we get the sum of a and b 
                // after that this sum will be multiplied by a and assigned to c

c = (a + b) / (a - b); // if there are several operations in brackets, 
                // they will be performed  
c = a + b*3.0;  // according to mathematic rules first you will get 
                // multiplication b and 3, and then the sum

Si necesitamos realizar una operación con una variable y le asignamos un resultado, por ejemplo añadir 5, lo haremos de una de las siguientes formas:

int a = 5;
a = a + 5;  // add 5 
a += 5;     // analogous 
a = a*5;
a *= 5;     // multiply a by 5 and assign to it 
a /= 5;     // divide and assign

Si queremos añadir o restar 1, usaremos el método siguiente:

int a = 5;
a++;  // add1, it is called increment
а--;  // subtract 1, it is decrement

Está todo bien, pero al trabajar con dichos scripts solo podemos adivinar si todo está correctamente, ya que la pantalla no nos indicará nada.

Por esta razón es conveniente mostrar los resultados. Para este propósito hay una función integrada MessageBox().

MessageBox()

Una función es un conjunto de instrucciones que acepta parámetros y en función de estos muestra el resultado. En nuestro caso, la función MessageBox() acepta dos parámetros: primero el mensaje de texto y en segundo lugar el texto del título. Este es un ejemplo:

MessageBox("Hello, World! There is some text.","caption");

Para ejecutar una función, primero escribimos su nombre. No debemos olvidar que es sensible a mayúsculas y minúsculas. Luego abrimos corchetes y escribimos los parámetros usando las comas. En nuestro caso, los parámetros son del tipo string. Como recordaremos, todas las líneas se escriben entre comillas ("). Al igual que cualquier instrucción, ponemos un punto y coma al final. Para comprenderlo adecuadamente veamos la imagen. Esta muestra cómo están relacionados el código y los resultados:

Por supuesto, todo está bien. Pero ¿cómo podemos mostrar las variables de los demás tipos? Muy fácil, con una nota mental:

int a = 50; 
int b = 100;   
MessageBox("It is very simple. a+b=" + (a + b), "a+b=?")

Como resultado obtenemos:

Como habrá podido adivinar, MQL4 está diseñado expresamente para que cuando intentemos añadir otro tipo de número a una línea, este transfiera automáticamente los números a las líneas y los combine. Es una propiedad realmente maravillosa. Puede hacer estas operaciones también con variables de tipo string:

int a = 50; 
int b = 100; 
string str1 = "a + b =";   
str1 += a + b; // now str1 = "a + b = 150"   
// now use the variable str1 as 
// a first parameter
MessageBox(str1, "a + b = ?");

Ahora ya sabe cómo extraer distintos datos usando la función MessageBox(). Pero ¿qué interés tiene mostrar los resultados de operaciones matemáticas simples? Necesitamos que MQL4 no solo encuentre las sumas y las multiplicaciones, ¿verdad?

Matrices

No se asuste. Es muy fácil. Mire. Suponga que quiere recordar cinco precios. ¿Qué debemos hacer? Bueno, podemos hacer esto:

double price1 = 1.2341; 
double price2 = 1.2321; 
double price3 = 1.2361; 
double price4 = 1.2411; 
double price5 = 1.2301;

Tenemos cinco variables que tienen un tipo de dato y describen un parámetro: el precio. Podemos hacerlo de otro modo, usando una matriz. Una matriz es un conjunto de variables que se diferencian en los índices, pero tienen un nombre. Así es cómo declaramos una matriz a partir de cinco elementos:

double price[5];

Forma común:

(tipo de matriz) (nombre de la matriz) [número de elementos];

En nuestro caso, tipo de matriz: doble; nombre: precio y número de elementos: 5. Veamos cómo podemos hacer referencia a los elementos de la matriz:

double price[5];   // declare an array of 5 elements

price[0] = 1.2341; // refer to the first element of the array and 
                   // assign a price to it. Note 
                   // that the index of the first element starts with 0 
                   // It is an important feature,
                   // you should get used to it.   

price[1] = 1.2321;  // refer to the second element 
price[2] = 1.2361;  // and so on 
price[3] = 1.2411; 
price[4] = 1.2301;

Podemos realizar cualquier tipo de operación con los elementos de la matriz, al igual que las variables comunes. En realidad, los elementos de una matriz son variables comunes:

double price[2];   
price[0] = 1.2234; 
price[1] = 1.2421;   
MessageBox("Middle price is " + (price[0] + 
           price[1]) / 2.0,"middle price");

Cuando declaramos una matriz, podemos asignar valores iniciales a todos los elementos:

double price[2] = {1.2234, 1.2421};

Tan solo enumeramos los valores iniciales de los elementos coma separados por corchetes. En tal caso, podemos indicar a un compilador que automáticamente ponga el número de elementos, en lugar de escribirlos nosotros mismos:

double price[] = {1.2234, 1.2421};

Sin duda todo está correcto, pero...Por desgracia no tiene ninguna utilidad. Debemos obtener de algún modo los datos reales. Por ejemplo, los precios actuales, tiempo, cantidad de dinero y así sucesivamente.

Matrices y variables integradas o incorporadas

Por supuesto, no podemos hacer nada sin datos reales. Para tener acceso a estos, debemos simplemente hacer referencia a la matriz incorporada correspondiente. Hay varias matrices de este tipo, por ejemplo:

High[0];   // refer to the last maximal price, 
           // that the bar has achieved in the current timeframe 
           // and current currency pair. Currency pair and 
           // the timeframe depend on the chart, on which you 
           // have started a script. It is very important to remember! 

Low[0];    // minimal price of the last bar 
           // in the current chart. 

Volume[0]; // value of the last bar in the current chart.

Para comprender adecuadamente las matrices e índices integrados, veamos lo siguiente:

Vemos que el índice de la última barra (número) es 0, y a continuación de la última está el 1, y así sucesivamente.

Hay también variables comunes incorporadas. Por ejemplo, Bars muestra el número de barras en el gráfico actual. Es una variable común, pero fue declarada antes y fuera de nuestro script. Esta variable siempre existe, como cualquier otra matriz y variable integrada.

Ciclos

Supongamos que decidimos calcular el valor medio de los precios máximos de todas las barras del gráfico. Para ello añadimos alternativamente cada elemento a una variable, por ejemplo:

double AveragePrice = 0.0;   
AveragePrice += High[0];
AveragePrice += High[1]; 
AveragePrice += High[2]; 
AveragePrice += High[3]; 
AveragePrice += High[4];   // ... and so on
AveragePrice /= Bars;

Puedo decirle solo esto: puede que funcione, pero es absurdo. Para esta finalidad están los ciclos. Recuerde que todas las operaciones son absolutamente idénticas, solo cambia el índice desde 0 hasta el valor de la variable Bars-1. Habría sido mucho más recomendable establecer de alguna forma un contador y usarlo para hacer referencia a los elementos de la matriz. Podemos solucionar esta tarea usando los ciclos:

double AveragePrice = 0.0;   
for(int a = 0; a < Bars; a++)
{     
    AveragePrice += High[a];
}

Veamos cada línea:

double AveragePrice = 0.0; // everything is clear
// this is a cycle.
or(int a = 0; a < Bars; a++)

Vemos que el ciclo comienza con una palabra clave for. (Hay otros tipos de ciclos, por ejemplo while, pero no los aprenderemos ahora). Luego en el contador separado por punto y coma punto y comillas, condiciones de operación del ciclo y operación de incremento del contador. En un caso general, puede presentarse de esta forma:

for(declaration of a counter; the cycle operation conditions;
   counter changes)
  {
    // the source code, that will be repeated is in braces,
  }

Vamos a ver cada etapa de la declaración de un ciclo con mayor detalle.

Declaración del contador: se usa el tipo int para el contador. El nombre de la variable-contador no importa. Debemos inicializar el valor primario, por ejemplo por 0.

Condiciones de funcionamiento del contador: es todo fácil. Aquí establecemos una condición y, si es verdadera, el ciclo continúa. De lo contrario se detiene el ciclo. Por ejemplo, en nuestro caso:

a < Bars

Está claro que el ciclo seguirá mientras la variable-contador sea menor que la variable Bars. Supongamos que la variable Bars=10, en tal caso en cada pasada del ciclo la variable aumentará en 1 hasta que alcance el valor de 10. Después de esto el ciclo se detendrá.

Cambio del contador: ¿y si no cambiamos el contador (en nuestro caso si no lo incrementamos)? El ciclo nunca terminará, ya que la condición nunca se cumplirá. Para comprender mejor el significado del ciclo, he escrito un código que ejecutará un ciclo con comentarios descriptivos:

// the cycle:
// double AveragePrice=0.0;
//
// for(int a=0;a>
// {
//   AveragePrice+=High[a];
// }
//
// will be performed in this way:
//

double AveragePrice=0.0;

int a=0;

AveragePrice+=High[a];
a++;                    // now a=1, suppose Bars=3.
                        // then the cycle goes on, because Bars > a 

AveragePrice+=High[a];
a++;                   // a=2

AveragePrice+=High[a];
а++;                   // a=3

// the conditions is not fulfilled any more, so the cycle 
// stops, because a=3 and Bars=3

Ahora debe conocer cómo funciona un ciclo. Pero debe saber algunos detalles más.

Las condiciones de funcionamiento del ciclo puede ser distintas. Por ejemplo como esto:

a>10    // the cycle works while a>10
a!=10   // the cycle works while a is not equal to 10
a==20   // while a is not equal to 20
a>=2    // while a is more or equal to 2
a<=30   // while a is less or equal to 30

El contador puede cambiarse de forma distinta. Por ejemplo, no tiene que incrementarlo cada vez en el valor 1. Puede hacerlo de esta forma:

a--     // the counter will each time decrease by 1 
a += 2  // the counter will each time increase by 2

Además, puede colocar el cambio del contador dentro del cuerpo del ciclo. Por ejemplo:

for(int a=0; a<Bars;)
 {
   AveragePrice+=High[a];
   
   a++; // the counter changes inside the cycle body
  }
>

Tampoco es necesario declarar la variable-contador en el ciclo. Puede hacerlo de otra forma:

int a = 0;
 
for(;a < Bars;)
 {
   AveragePrice += High[a];
 
   a++; // the counter changes inside the cycle body
 }

Si el cuerpo del ciclo solo contiene un operador, por ejemplo este:

for(int a = 0; a < Bars; a++)
 {
   AveragePrice += High[a];
 }

entonces no es necesario poner corchetes:

for(int a = 0; a < Bars; a++)
    AveragePrice += High[a];

Todo consiste en ciclos hasta ahora. Hay otros tipos de ciclos, pero los discutiremos en la próxima lección. Ahora debe saber cuándo usar los ciclos y recordar la sintaxis. Intente escribir varios ciclos que le muestren los valores del contador a través de la función MessageBox(). Intente escribir un ciclo descontinuo y ve qué ocurre después de su inicio.

Condiciones

Hay una cosa importante más que siempre usará: las condiciones. Nuestra vida está repleta de condiciones y acciones que siguen estas condiciones. Con mucha frecuencia pensamos mediante cláusulas condicionales. Por ejemplo: "Si tuviera tiempo suficiente, leería este libro. Si no, entonces leería mejor una revista". Puede crear centenares de dichas condiciones y acciones. Pero, ¿cómo podemos escribirlas en MQL4? Este es un ejemplo:

// of course the conditionsn should be written in MQL4
if( I have enough time )   
  {  
    // here we place any actions, directions in MQL4
    will read this book; 
  }
// if the first condition is not fulfilled, 
// the second is fulfilled
else   
  {
    read a magazine;  // code
  }

Ahora debe conocer la sintaxis de las condiciones. Veamos las condiciones completamente escritas en el lenguaje MQL4:

int a = 10;
int b = 0;
 
if(a > 10 )
  {
    b = 1;
  }
else
  {
    b = 2;
  }
 
MessageBox("b=" + b,".");

Todo es bastante fácil. ¿Cuál es el valor de b después de finalizar? Por supuesto, b=2, ya que la condición a > 10 no se cumple. Es fácil. A propósito, no es necesario usar la palabra clave else:

int a = 10;
int b = 0;
 
if(a > 10)
  {
    b = 1;
  }

En este caso, si no se cumple una condición, el bloque de código que sigue a la condición dentro de corchetes se omite. En nuestro caso, al cumplirse b=0. Debe prestar también atención a la forma en que se crean las condiciones. Sabemos que cada tipo de variable puede tomar valores distintos, por ejemplo:

• int: enteros (1, 60, 772);
• double – con coma flotante (1.0021, 0.221);
• string – solo líneas ("Palabra", "Algún texto.");
• bool – solo verdadero o falso (verdadero, falso).

Por tanto, la conclusión es: en las condiciones, comparamos las variables solo con los valores que pueden aceptar, por ejemplo:

int Integer=10;
double Double=1.0;
string String="JustWord";
bool Bool=true;
 
if(Integer<10) // the condition is correct
{
  MessageBox("It works!","Really!");
}
 
if(Double!=1.0) // the condition is correct
{
   MessageBox("works!","Simple!");
}
 
if(String==10) // this is nonsense!! 
               // we found the variable 
               //String with string type, but 10 is int
{
   MessageBox("Wrong type","u can't c this");
}
 
if(String!="Word") // ok
{{
  // ...
}
 
if(Bool==true) // correct
{
  // ...
}

Recuerde que hacemos comparaciones usando los operadores de condición (==, !=, >, <, >=, <=). Para los tipos string y bool solo usamos las comparaciones == y !=.

Ahora ya estamos familiarizados con el significado de las inclusiones. Sí, podemos usar las condiciones en los ciclos y los ciclos en las condiciones. Podemos usar las condiciones en otras condiciones, y así sucesivamente. Por ejemplo:

int a=0;
double b=0.0;
bool e;
 
if(a==0)
{
  for(int c=0;c<Bars;c++)
  {
     b+=High[c];
  }
  
  if(b>500.0)
  {
     e=true;
  }
  else
  {
     e=false;
  }
}

El siguiente ejemplo muestra otra forma de usar las condiciones:

int a=0;
int result;
 
if(a==0)
{
  result=1;
}
else if(a==1)
{
  result=2;
}
else if(a==2)
{
  result=3;
}
else
{
  result=4;
}

Si en el caso de una condición que no se cumple tenemos otra condición, la escribimos después de la palabra clave "else", como el código anterior. Esto también funcionará. El número de condiciones adicionales es ilimitado. Si las acciones resultantes del cumplimiento de una condición se ajusta a una operación, podemos omitir los corchetes como en los ciclos:

if(a==1)
{ 
  b=2;
} 

// or this way:

if(a==1)
  b=2;

Condiciones complejas

Con mucha frecuencia una condición no es suficiente. Necesitamos comparar muchos parámetros, y aquí tenemos que usar condiciones complejas. Por ejemplo, si tengo tiempo y paciencia suficiente, aprenderé el lenguaje MQL4. Podemos escribirlo como un código:

if((enough time) && (enough oatience))
{
     I will learn MQL4 language;
}

Esto significa que debemos primero dividir las condiciones complejas en condiciones simples, ponerlas entre corchetes y colocar && (operador lógico AND) o || (operador lógico OR) entre ellas. Si ambas condiciones deben ser verdaderas, ponemos && (AND). Si solo una de las condiciones debe ser verdadera, ponemos || (OR). Este es un ejemplo:

nt a=10;
int b=20;
 
if((a>5) && (b<50))
  MessageBox("Its works!","Yes");

Además, podemos encerrar y combinar tantas condiciones como necesitemos:

int a=10;
int b=20;
 
if ( ((a>5) || (a<15)) && ( b==20))
  MessageBox("It works, too!","Yes");

Todo junto

Usando conjuntamente condiciones simples y complejas y los ciclos, podemos escribir código muy complejo. Casi cualquier mecanismo puede ser descrito usando estas estructuras del lenguaje MQL4. Si sabe cómo se escriben y funcionan estas sencillas cosas, comprenderá la mitad del lenguaje MQL4 y de cualquier otro lenguaje. Es realmente muy fácil. Todo lo que necesita es práctica. Intente escribir tantos scripts como pueda para recordar la sintaxis y practicar. Además, vea los ejemplos en el archivo adjunto examples.mq4 e intente comprenderlos.

Otras variables y matrices integradas

Ya conoce las matrices como High[], Low[], Volume[] y una variable Bars. Estas son algunas variable útiles más:

double Open[]  // the array of prices of the current
               // chart opening bars
double Close[] // the array of prices of the current 
               // chart closing bars 

double Bid  // the last known buying price in 
            // the current currency pair
double Ask  // the last known selling price in
            // the current currency pair

Conclusión

Ha aprendido una gran cantidad de cosas nuevas. Probablemente tienen un lío en la cabeza. Vuelva a leer el texto, recuerde, practique e intente comprender el significado. Se lo prometo, muy pronto todo quedará claro. Los que se ha escrito en este artículo son los fundamentos de todo el lenguaje MQL4. Cuanto mejor comprenda este material, más fácil le será seguir estudiando el resto del material. Y le diré aún más: será mucho más sencillo estudiar el resto, ya que el material descrito en este artículo es la parte más difícil. En los siguientes artículos estudiaremos las distintas peculiaridades del lenguaje MQL4 y veremos otras funciones integradas que ofrecen grandes posibilidades en la programación.