Язык MQL 4 для "чайников". Первое знакомство

Введение

Эта серия статей рассчитана на трейдеров, которые ничего не знают о программировании, но хотят изучить язык MQL4 максимально быстро с минимальными усилиями и затратами времени. Если вы боитесь таких словосочетаний, как "объектная ориентация" или "трёхмерный массив", эта статья - то что вам нужно. Уроки рассчитаны на максимально быстрый результат. Кроме того, материал будет подаваться в доступной форме. Мы не будем сильно углубляться в теорию, зато практическую пользу вы получите уже на первом уроке.

Совет

Если вы действительно впервые сталкиваетесь с программированием, то в некоторых местах вам будет трудно уловить суть с первого раза. Медленно перечитывайте текст и обдумывайте каждое предложение. В конечном итоге вы все поймете, так как ничего сложного там в действительности нет. Не двигайтесь дальше, если полностью не поняли предыдущий материал. Изучайте примеры кода. Пишите свой код на основе того, что вы уже поняли.

Первое знакомство с MQL4

Для начала давайте разберемся, что вы можете делать с помощью этого языка. Он предназначен для создания скриптов, пользовательских индикаторов, советников и библиотек:

• Скрипты - это последовательности команд, программы, которые выполняются только один раз по вашему запросу. Они могут заменять действия, которые вы выполняете каждый день при торговле. Например, открывать ордера. Они также могут выполнять специфические действия - например, исследовать графики и выводить статистическую информацию.
• Пользовательские индикаторы - это технические индикаторы, написанные в дополнение к встроенным в терминал индикаторам. Они выводят графики или другую визуальную информацию. В отличие от скриптов, пользовательские индикаторы выполняются при каждом изменении цены, то есть на каждом тике. То, что будут выводить индикаторы, зависит только от вас. Это может быть бесполезный график синуса или что-то, что будет помогать вам ориентироваться в ситуации на рынке. Например, если вы точно знаете, при каких условиях на рынке тренд, а при каких флэт, то это наверняка можно написать в виде индикатора.
• Советники - это механические торговые системы, которые привязаны к любому финансовому инструменту. Подобно пользовательским индикаторам, советники выполняются при каждом новом тике, но в отличие от первых могут информировать вас о состоянии рынка (например, давать конкретные советы о покупке или продаже) или торговать самостоятельно без вашего участия. Терминал поддерживает тестирование стратегий, что позволяет быстро оценить прибыльность вашего советника. Вы описываете свою стратегию на языке MQL4, а терминал хладнокровно выполняет все ваши указания.
• Библиотеки - это наборы функций для выполнения специфических задач. Например, один из ваших советников может использовать специальные математические функции для принятия решения о том, когда выполнять покупку, а когда - продажу.

В этой статье мы научимся писать обычные скрипты. Для этого используется специальная программа - редактор MetaEditor 4. Чтобы её запустить, нажмите на клавишу F4 при открытом клиентском терминале. Чтобы создать новый скрипт, нажмите в редакторе MetaEditor 4 на кнопки меню File->New или используйте сочетание клавиш Ctrl+N на клавиатуре:

После этого появится окно, в котором вам следует указать, что вы собираетесь создать. Выбираем Script и жмём на кнопку Далее:

В следующем окне следует ввести название скрипта в поле Name. Укажите свое имя в поле Author и e-mail или адрес вашего веб-узла в поле Link. Далее нажимаем на кнопку Готово:

После этого откроется новое окно, с которым вы в дальнейшем будете работать больше всего. В нём отображается исходный текст:

Обратите внимание, что даже пустой, ничего не делающий скрипт включает в себя какой-то код. Теперь всё готово для начала программирования. Но, к сожалению, вы не имеете представления, как это делается. Давайте попробуем исправить ситуацию.

Исходный текст, компиляция и прочее

Вы должны понять важную вещь. То, что будет написано в MetaEditor'e, - это исходный код. То есть последовательность команд, которую будет выполнять терминал одну за другой сверху вниз. Но терминал не может выполнять исходные коды. Исходный код понятен вам, но не MetaTrader'у. Чтобы исходный код был понятен терминалу, его нужно "перевести" на соответствующий "язык". Чтобы это сделать, нужно нажать на клавишу F5 в MetaEditor'е. После этого будет выполнена компиляция исходного кода в исполняемый файл. Компиляция - это процесс "перевода" исходного кода, написанного вами и понятного вам, в специальный исполняемый файл, который понимает и способен выполнить MetaTrader. Проверьте это сами. Создайте новый скрипт под названием Test1 и сохраните, но не компилируйте. Запустите терминал и, используя Навигатор, зайдите в раздел "Скрипты". Как видно, скрипта с названием Test1 нет:

Теперь скомпилируйте скрипт (клавиша F5):

Опять загляните в терминал. Скрипт Test1 появился:

Двойной клик на названии скрипта в Навигаторе терминала - и он запускается. Но ничего не происходит, так как скрипт пуст.

Вы уже должны представлять, на что похож процесс написания скрипта: вы пишете исходный код, компилируете, запускаете скрипт в терминале, смотрите на результат, изменяете исходный код, компилируете, смотрите ... и так - до тех пор, пока не получите нужный результат.

Где писать скрипты?

Вы уже заметили, что пустой скрипт содержит в себе определённый код. Но в каком месте вам следует вписывать исходный код, чтобы он работал? Его нужно вписывать между строками int start(){ и return(0);}, как показано на рисунке:

Всё, что я дальше буду вам предлагать писать, размещайте в этом месте - и всё будет работать. Позже мы рассмотрим более детально, что означают все эти строки.

Переменные

Что такое переменная? Попробуйте сами ответить на этот вопрос, а я вам помогу. Сколько вам лет? Сколько вам будет лет через пять лет? Теперь смотрите: возраст - это и есть переменная. Возраст изменяется с течением времени, как и любая другая переменная. То есть первая особенность переменной заключается в её изменении с течением времени. Другой пример: какой был ваш рост в пять лет? Очевидно, намного меньше, чем сейчас. Рост - ещё один пример переменной. Но есть важное отличие. Обратите внимание на то, что возраст мы измеряли, используя целые числа. Рост намного удобнее измерять, используя десятичные дроби ("числа с плавающей точкой"). Возраст: 20 лет, 30 лет. Рост: 1,8 метра, 1,95 метра. Это очень важная особенность: каждая переменная относится к определённому типу. Давайте посмотрим, какие еще бывают типы переменных. Вы можете описать числами многие параметры, но как представить текст? Для этого используются специальные типы - строковые. Эти типы переменных хранят только строки. Теперь давайте посмотрим, как можно создать и описать переменную на языке MQL4. Пример:

int age = 25;

Здесь мы объявили переменную целого типа (int - integer - целое число). int - это ключевое слово языка MQL4, которое указывает, что мы используем тип целых чисел. Дальше мы написали age (возраст) - это название переменной, то есть слово, по которому мы будем обращаться к значению, хранящемуся в этой переменной. Затем мы присвоили переменной значение 25, используя символ "=". После каждой инструкции ставится точка с запятой, что мы и сделали. Обратите внимание - объявление и инициализация любой переменной сводятся к такой форме:

[тип переменной] [название переменной] = [значение переменной];

Кстати, присваивать какое-то значение переменной (совершать инициализацию) необязательно, вы могли бы написать и так:

int age;

Еще один пример:

double height = 1.95;

Здесь мы объявляем переменную с названием height (рост), которая хранит значения типа double (число с плавающей запятой, десятичная дробь) и которой мы сразу присваиваем значение 1.95, используя оператор "=".

Теперь рассмотрим строковую переменную:

string name = "Janet";

string - тип переменной, name - название переменной, "Janet" - значение переменной. Обратите внимание, что значения для переменной типа string размещаются между двойными кавычками (").

Существует еще один очень полезный тип переменной - bool. Переменные этого типа могут принимать только два значения: либо true (правда), либо false (ложь). Пример:

bool trend = false;

Теперь вам нужно запомнить несколько важных вещей. Язык MQL4 - это регистрозависимый язык, то есть имеет большое значение, ПРОПИСНЫМИ буквами вы пишете код или строчными. Например, если вы объявите несколько переменных с одинаковыми названиями, но разным регистром, то это будут совершенно разные переменные:

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

Вышеприведённый код создаст четыре совершенно разных переменных. Также обратите внимание на то, что все ключевые слова языка MQL4 пишутся строчными буквами.

Следующий пример:

DOUBLE hightPrice1; 
Double hightPrice2;

Вышеприведённый код работать не будет, потому что слово double не будет воспринято как ключевое слово языка MQL4. Ещё один важный момент заключается в том, что названия переменных не могут начинаться с цифр или специальных знаков (*,&, ,%,$). Например:

double 1price;
double %price;

Ещё один элемент языка - комментарии. Если вы напишете "//" перед строкой, то она целиком закомментируется. Это значит, что при компиляции она будет игнорироваться. Например:

// this is a comment 

Теперь вы должны заметить, что код пустого скрипта включает в себя много комментариев, которые несут информативный характер. Комментируйте свой код, иногда это может сэкономить вам много времени.

Работа с переменными

Теперь давайте разберёмся, что можно делать с переменными после того, как мы их объявили. Рассмотрим простой пример:

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

Если нужно выполнить какую-то операцию с переменной и присвоить ей же результат, например, увеличить на 5, то поступают одним из следующих способов:

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

Если хотите увеличить или уменьшить переменную на 1, используйте такой метод:

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

Это всё очень хорошо, но вы при выполнении подобных скриптов можете только догадываться, правильно всё работает или нет, так как на экране ничего не происходит.
Поэтому удобно выводить результаты. Для этого существует встроенная функция MessageBox().

MessageBox()

Функция - это какой-то набор инструкций, который принимает параметры и в зависимости от них выводит результат. В нашем случае функция MessageBox() принимает два параметра: первый - текст сообщения, второй - текст заголовка. Вот пример использования функции:

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

Чтобы вызвать функцию, сначала пишут её название. Не забывайте про регистр! Потом открываются скобки, и в них через запятую пишутся параметры. В нашем случае параметры имеют строковый тип. Как мы помним, все строки пишутся между двойными кавычками ("). Как в любой инструкции, в конце ставим точку с запятой. Чтобы окончательно разобраться, посмотрите на рисунок. Он показывает, как связаны код и результат:

Да, это всё, конечно, хорошо. Но как можно вывести переменные других типов? Очень просто - мотайте на ус:

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

В результате получим:

Как вы уже догадались, MQL4 устроен таким образом, что когда мы пытаемся добавить к строке какой-то другой числовой тип, то он автоматически переводит числа в строки и объединяет их. Это действительно замечательное свойство! Подобные операции вы можете делать и с переменными-строками:

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 = ?");

Теперь вы знаете, как можно выводить различные данные с помощью функции MessageBox(). Но какой интерес выводить результаты элементарных математических операций? Нам ведь MQL4 нужен не для того, чтобы находить суммы и произведения, не так ли?

Массивы

Не пугайтесь. Это очень просто. Смотрите. Допустим, вы хотите запомнить пять цен. Как можно поступить? Ну, можно вот так:

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

У нас получается пять переменных, которые имеют один тип данных и описывают один и тот же параметр - цену. Но можно поступить иначе, используя массив. Массив - это всего лишь серия переменных, которые отличаются между собой индексами, но имеют одно общее название. Посмотрите, как нужно объявлять массив из пяти элементов:

double price[5];

Общая форма:

(тип массива) (название массива) [количество элементов];

В нашем случае: тип массива - double, название - price, количество элементов - 5. Давайте посмотрим, как можно обратиться к элементам массива:

double price[5];   // объявляем массив из 5 элементов   
                  
price[0] = 1.2341; // обращаемся к первому элементу массива и 
                   // присваиваем ему цену. Обратите внимание 
                   // на то, что индекс первого элемента 
                   // начинается с 0. Это важная особенность,
                   // к которой нужно привыкнуть.   
 
price[1] = 1.2321;  // обращаемся ко второму элементу 
price[2] = 1.2361;  // и так далее 
price[3] = 1.2411; 
price[4] = 1.2301;

С элементами массива можно проделывать любые операции, как и с обычными переменными. Собственно, элементы массива - и есть обычные переменные:

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

При объявлении массива можно также присвоить всем элементам начальные значения:

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

Мы просто перечисляем через запятую начальные значения элементов в фигурных скобках. В таком случае вы можете даже не указывать количество элементов, компилятор автоматически вставит нужное значение:

double price[] = {1.2234, 1.2421};

Это всё, безусловно, очень хорошо, но... К сожалению, бесполезно. Нам нужно как-то добраться до реальных данных! Например, текущих цен, времени, количества свободных денег и так далее.

Встроенные или предопределённые массивы и переменные

Конечно же, без реальных данных не обойтись. Чтобы получить к ним доступ, достаточно обратиться к соответствующему предопределённому массиву. Таких имеется несколько, например:

High[0];   // обращаемся к последней максимальной цене, 
           // которой достиг бар на текущем таймфрейме 
           // и текущей валютной паре. Валютная пара и 
           // таймфрейм зависят от графика, на котором 
           // вы запустили скрипт. Это очень важно 
           // запомнить!
Low[0];    // минимальная цена последнего бара на 
           // текущем графике. 
Volume[0]; // объём последнего бара на текущем графике.

Чтобы окончательно разобраться в предопределённых массивах и индексах, посмотрите на это:

Как видите, индекс (номер) последнего бара - 0, предпоследнего - 1 и так далее.
Также существуют предопределённые обычные переменные. Например, Bars показывает, сколько баров загружено на текущем графике. То есть это самая обычная переменная, но её объявили до вас и вне вашего скрипта. Эта переменная существует всегда, как и любые другие предопределённые массивы и переменные.

Циклы

Допустим вы решили посчитать среднее значение максимальных цен всех баров на графике. Для этого вы поочерёдно добавляете каждый элемент к какой-то переменной, например, так:

double AveragePrice = 0.0;   
AveragePrice += High[0];
AveragePrice += High[1]; 
AveragePrice += High[2]; 
AveragePrice += High[3]; 
AveragePrice += High[4];   // ... и так далее
AveragePrice /= Bars;

Скажу вам одно: это может сработать, но это - очень глупо. Для таких целей существуют циклы. Обратите внимание, что все операции абсолютно одинаковы, лишь индекс изменяется от 0 до значения переменной Bars-1. Было бы намного удобнее каким-то образом определить счётчик и с его помошью обращаться к элементам массива. Вот как можно решить эту же задачу, используя циклы:

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

Рассмотрим каждую строку:

double AveragePrice = 0.0; // тут всё и так понятно
// а это самый настоящий цикл.
for(int a = 0; a < Bars; a++)

Как видите, цикл начинается с ключевого слова for. (Существуют и другие типы циклов, например, while, но их мы пока не будем рассматривать.) Далее следуют кавычки, в которых размещаются последовательно через точку с запятой счётчик, условие выполнения цикла и операция увеличения счётчика. В общем случае это может быть представлено в виде:

for(объявление счетчика; условие выполнения цикла; 
    изменение счетчика)
  {
     // между фигурными скобками размещается исходный код,
     // который будет повторяться
  }

Рассмотрим каждую стадию объявления цикла более детально.

Объявление счетчика: используется тип int для счётчика. Название переменной-счётчика не имеет никакого значения. Также обязательно производите инициализацию начального значения, например, нулём.

Условие выполнения цикла: тут всё очень просто. Здесь определяется условие, и если оно истинно, то цикл продолжается. Иначе - цикл заканчивается. Например, в нашем случае:

a < Bars

Видно, что пока переменная-счётчик а будет меньше, чем переменная Bars, то цикл будет выполняться дальше. Допустим, переменная Bars=10, тогда с каждым проходом по телу цикла переменная а будет увеличиваться на 1, пока не достигнет 10, после чего цикл прекратится.

Изменение счетчика: если мы не будем изменять счётчик каким-то образом (в нашем случае не будем его увеличивать), то цикл никогда не закончится, так как условие никогда не будет выполнено. Чтобы лучше понять суть цикла, я написал код, который будет выполнять цикл с поясняющими комментариями:

// этот цикл:
// double AveragePrice=0.0;
//
// for(int a=0;a>
// {
//   AveragePrice+=High[a];
// }
//
// будет будет выполнен следующим образом:
//
 
double AveragePrice=0.0;
 
int a=0;
 
AveragePrice+=High[a];
a++;              // теперь а=1, предположим, что Bars=3.
                  // Тогда, так как Bars больше чем а, 
                  // то цикл продолжается
 
AveragePrice+=High[a];
a++;                   // а=2
 
AveragePrice+=High[a];
а++;                   // a=3
 
// но так как условие уже не выполняется, то цикл 
// прекращается, ведь теперь и а, и Bars равны трём.

Теперь вы должны понимать, как работает цикл. Но нужно знать ещё несколько моментов.

Условие выполнения цикла может быть другим. Например, таким:

a>10    // цикл выполняется, пока a больше 10
a!=10   // цикл выполняется, пока а не равно 10
a==20   // пока а равно 20
a>=2    // пока а больше или равно 2
a<=30   // пока а меньше или равно 30

Изменение счётчика может производиться и по-другому. Например, вам необязательно увеличивать его каждый раз на 1. Вы можете поступить иначе:

a--     // счётчик будет каждый раз уменьшаться на 1 
a += 2  // счётчик будет каждый раз увеличиваться на 2

Кроме того, вы можете разместить изменение счётчика внутри тела цикла. Например, так:

for(int a=0; a<Bars;)
 {
   AveragePrice+=High[a];
   
   a++; // счётчик изменяется внутри тела цикла
 }

Аналогично - необязательно объявлять переменную-счётчик в цикле. Можно сделать иначе:

int a = 0;
 
for(;a < Bars;)
 {
   AveragePrice += High[a];
 
   a++; // счётчик изменяется внутри тела цикла
 }

Если тело цикла содержит всего один оператор, например, вот так:

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

то фигурные скобки писать необязательно:

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

Пока это - всё, что касается циклов. Есть и другие виды циклов, но о них мы поговорим на следующем уроке. Сейчас вы должны уяснить, когда нужно использовать циклы, и запомнить их синтаксис. Попробуйте самостоятельно написать несколько циклов, которые бы выводили значения счётчика функцией MessageBox(). Попробуйте написать бесконечный цикл и посмотрите, что произойдет, если его запустить.

Условия

Осталась ещё одна важная вещь, которую вы будете постоянно использовать, - условия. В нашей жизни много условий и действий, которые следуют за этими условиями. Мы очень часто даже мыслим условными предложениями. Например: "Если у меня будет достаточно времени, я успею прочитать эту книгу. Если нет, то, пожалуй, лучше полистать свежий журнал. " Вы и сами можете придумать сотни подобных условий и действий. Но как записать их на MQL4? Вот пример:

// конечно, писать условия нужно на языке MQL4
if( у меня будет достаточно времени )   
  {  
    // а тут мы размещаем любые действия, команды на MQL4
    то дочитаю эту книжечку; 
  }
// если первое условие не выполняется, то выполняется 
// второе условие
else   
  {
    полистаю свежий журнальчик;  // код
  }

Теперь вы должны понимать синтаксис условий. Давайте посмотрим на условия, полностью написанные на языке MQL4:

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

Всё довольно-таки просто. Чему равно b после выполнения? Конечно, b = 2, потому что условие a > 10 не выполняется. Это элементарно. Кстати, использовать ключевое слово else (иначе) необязательно:

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

В таком случае, если условие не выполняется, блок кода, который следует после условия между фигурными скобками, пропускается. В нашем случае после выполнения b = 0. Также следует обратить внимание на то, как строятся условия. Нам известно, что разные типы переменных могут принимать разные значения, например:

• int - целые значения (1, 60, 772);
• double - с плавающей запятой (1.0021, 0.221);
• string - только строки ("Word", "Some text.");
• bool - только правда или неправда (true, false).

Так вот, к чему я веду: в условиях сравнивайте переменные только с теми значениями, которые они могут принимать, например:

int Integer=10;
double Double=1.0;
string String="JustWord";
bool Bool=true;
 
if(Integer<10) // условие построено правильно
{
  MessageBox("It works!","Really!");
}
 
if(Double!=1.0) // условие построено правильно
{
   MessageBox("works!","Simple!");
}
 
if(String==10) // а вот это уже полный бред!! 
               // Мы определили переменную 
               //String с типом string, а 10 это int
{
   MessageBox("Wrong type","u can't c this");
}
 
if(String!="Word") // другое дело
{
  // ...
}
 
if(Bool==true) // правильно
{
  // ...
}

Обратите внимание, что мы производим сравнения при помощи условных операторов (==, !=, >, <, >=, <=). Для типов string и bool используйте только такие операторы сравнения как == и !=.

Теперь вы должны ознакомиться с таким понятием, как вложенность. Да, вы можете использовать условия в циклах, а циклы в условиях; вы можете использовать в условиях другие условия и так далее. Например:

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;
  }
}

Следующий пример показывает ещё один способ использования условий:

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;
}

Если при невыполнении какого-то условия у вас имеется другое условие, тогда напишите его после ключевого слова else, как в коде выше. Это тоже замечательно сработает. Количество других условий не ограничено. Если действия по выполнению условия умещаются в одну операцию, то фигурные скобки, как и в циклах, можно упустить:

if(a==1)
{ 
  b=2;
}
 
// а можно и так:
 
if(a==1)
  b=2;

Сложные условия

Часто одного условия бывает маловато. Приходится сравнивать много параметров, и в таком случае без сложных условий не обойтись. Например, если у меня будет достаточно времени и терпения, я выучу язык MQL4. Это можно записать в виде кода так:

if((достаточно времени) && (достаточно терпения))
{
     я выучу язык MQL 4;
}

То есть сложное условие сначала нужно разбить на простые условия, заключить их в скобки, а потом между ними поставить && (логическое И) или || (логическое ИЛИ). Если нужно, чтобы оба условия были истинны, тогда используем && (И). Если нужно, чтобы истинным было или первое, или второе условие, то используем || (ИЛИ). Вот настоящий пример:

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

Кроме того, вы можете вкладывать и объединять сколько угодно условий:

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

Всё вместе

Используя вместе сложные и простые условия, а также циклы, вы можете написать очень сложный код. Практически любой алгоритм можно описать, используя эти незамысловатые структуры языка MQL4. Если вы поймете, как пишутся и работают эти простые вещи, вы поймёте половину из того, что из себя представляет MQL4 или любой другой язык программирования! Это действительно очень просто! Всё, что вам нужно, - это практика. Постарайтесь написать как можно больше скриптов, чтобы запомнить синтаксис языка и набраться опыта. Кроме того, просмотрите примеры, которые размещены в прикреплённом файле examples.mq4 и постарайтесь разобраться в них.

Другие предопределённые переменные и массивы

Вам уже известны массивы High[], Low[], Volume[] и переменная Bars. Ниже приведены еще некоторые полезные переменные:

double Open[]  // массив цен открытия баров текущего 
               // графика
double Close[] // массив цен закрытия баров текущего 
               // графика
 
double Bid // последняя известная цена покупки на 
           // текущей валютной паре
double Ask // последняя известная цена продажи на 
           // текущей валютной паре

Заключение

Итак, вы узнали много нового. Уверен, что в вашей голове сейчас полный беспорядок. Перечитывайте текст, запоминайте, практикуйтесь и вникайте в суть. Обещаю, скоро всё станет на свои места. То, что описано в этой статье, - основа всего языка MQL4. Чем лучше вы освоите этот материал, тем проще вам будет учиться дальше. Скажу больше - учиться дальше будет намного легче, так как изложенный здесь материал - это самая трудная часть. В следующих статьях мы изучим различные особенности языка MQL4, а также ознакомимся с другими встроенными функциями, которые предоставляют огромные возможности для программирования.