Как написать скрипт mt4

Создание

Для создания скриптов используются язык программирования торговых стратегий MetaQuotes Language 4 (MQL4) и редактор MetaEditor. Чтобы запустить редактор советников, необходимо выполнить команду «Создать» контекстного меню окна «Навигатор — Скрипты», команду меню «Сервис — Редактор MetaQuotes Language», нажать клавишу F4 или кнопку панели «Стандартная». При создании MQL4-программы автоматически откроется мастер создания советников, позволяющий быстро создавать новые MQL4-программы. В нем в качестве типа создаваемого объекта необходимо указать «Скрипт»

и заполнить поля требуемыми данными:

.

• Имя — название скрипта;
• Автор — имя автора;
• Ссылка — адрес сайта разработчика.

После этого в редакторе открывается окно нового скрипта. Файл с исходным текстом (*.MQ4) скрипта автоматически помещается в папку /EXPERTS/SCRIPTS клиентского терминала. С этого момента можно приступать к написанию исходного текста программы.

По завершении разработки необходимо скомпилировать скрипт. Для этого в редакторе советников необходимо выполнить команду меню «Файл — Компилировать», нажать клавишу F5 или кнопку панели инструментов. В результате успешной компиляции создается исполняемый файл программы с расширением *.EX4, автоматически помещаемый в папку /EXPERTS/SCRIPTS. Список всех скриптов можно просмотреть в окне «Навигатор — Скрипты» клиентского терминала.

Редактирование скриптов

Чтобы приступить к редактированию уже существующего скрипта из терминала, необходимо выполнить команду «Изменить» контекстного меню окна «Навигатор — Скрипты». При этом откроется редактор советников, в который уже будет загружен исходный текст выбранного скрипта. После изменения исходного кода необходимо повторно скомпилировать его и получить новый исполняемый EX4-файл. В противном случае в терминале будет использоваться неизмененная, предыдущая версия MQL4-программы.

На прошлом уроке «Язык MQL — Урок 2» мы научили наш первый скрипт MT4 — «test», написанный на языке MQL4 рассчитывать размер лота, а точнее запрашивать у нас размер средств которыми мы хотим рискнуть при торговле на форекс при помощи терминала Metatrader 4. В данном уроке я предлагаю заняться самим расчетом данного лота !

Для расчета желаемого лота, скрипту MT4 необходимо знать «какими средствами мы располагаем» на нашем депозите форекс. Можно конечно в ручную ему это сообщать (как мы сделали с риском), но зачем делать лишнюю работу, если в нашем распоряжении язык MQL4? Пусть наш скрипт «test» сам берет эту цифру из торгового терминала Metatrader 4 !

Для этих целей (для определения размера средств в MT4)  в языке MQL4 предназначена функция — AccountFreeMargin()

Все вычислительные операции в советниках или скриптах MQL необходимо делать в функции start.

Поэтому добавим в эту функцию строчку:
double Free=AccountFreeMargin();

теперь в переменной типа double (число с плавающей точкой) и именем Free у нас будет содержаться размер свободных средств.

Еще нам необходимо знать стоимость одного лота по заданной валютной паре — для этого воспользуемся функцией MarketInfo(string symbol, int type).

Эта функция возвращает различную информацию в зависимости от переданных ей параметров. Первым идет строковый параметр для указания валюты. Можно указать напрямую (например: «EURUSD»), но мы хотим универсальности от нашего скрипта, написанного на MQL (что бы скрипт сам определял валютную пару на графике, котором он запущен).

Воспользуемся функцией Symbol() котороя вернет нам название текущей валюты.

Второй параметр функции MarketInfo используем: MODE_MARGINREQUIRED (Размер свободных средств, необходимых для открытия 1 лота)

Теперь соберем все вместе и получим:
double One_Lot =MarketInfo(Symbol(),MODE_MARGINREQUIRED);
Итак, переменная One_Lot будет содержать стоимость одного лота по текущей валюте.
С помощью простейших математических операций рассчитаем НАШ лот:
double Lot= Free*MaxRisk/100/One_Lot;
Free — свободные средства
MaxRisk/100 — процент(наш параметр MaxRisk надо перевести в %. Для этого его делим на 100)
One_Lot — стоимость одного лота

Пример расчета лота для EURUSD (курс для примера возьмем 1.4615):
у нас есть Free=1000$ (свободные средства)
MaxRisk= 2
2% от 1000$ это 1000*2/100=20$

стандартный размер контракта (1 лот) = 100000
при покупке 100000 EUR мы должны заплатить 100000*1.4615=146150$
но у нас есть плечо (возьмем для примера 500), соответственно мы заплатим One_Lot=146150/500=292.3$ (все эти вычисления делает MarketInfo(Symbol(),MODE_MARGINREQUIRED))

Наш лот получится: Lot=20/292.3= 0,0684

Хорошо! Оптимальный лот для открытия торговой позиции в Metatrader 4  мы рассчитали.

А как же его теперь увидеть на экране монитора?
Для этого воспользуемся функцией Alert(), в качестве параметра укажем НАШ рассчитанный лот.

//±——————————————————————+
//| test.mq4 |
//| Copyright © 2009, MetaQuotes Software Corp. |
//| http://www.metaquotes.net |
//±——————————————————————+
#property copyright «Copyright © 2009, MetaQuotes Software Corp.»
#property link «http://www.metaquotes.net»
#property show_inputs
extern int MaxRisk=2;
//±——————————————————————+
//| script program start function |
//±——————————————————————+
int start()
{
//—-
double Free =AccountFreeMargin();
double One_Lot =MarketInfo(Symbol(),MODE_MARGINREQUIRED);
double Lot =Free*MaxRisk/100/One_Lot;
Alert(Lot);
//—-
return(0);
}
//±——————————————————————+

Ну и теперь компилируем и запускаем наш экспериментальный скрипт МТ4 — «test« (это мы уже делать умеем из прошлого урока MQL — 2).

В итоге мы получим следующее сообщение в терминале MT4:

В следующем уроке по изучению языка MQL, мы продолжим улучшать наш скрипт для Metatrader 4 и наполнять его полезными функциями.

Здравствуйте! Начнем урок с самого простого, создадим свой первый скрипт. Почему скрипт? Да потому что у него всего 1 функция, которая не имеет никаких параметров.

Что такое скрипт на форекс

Скрипт MQL4 – это программа для Meta Trader, которая выполняется какое-либо действие в терминале только один раз. Скрипт устанавливается (в простонародье — кидается) на график и происходит обработка функции OnStart(), после чего скрипт удаляется с графика. На этом его работа завершена. Выполнение в большинстве случаев осуществляется за один тик (по приходу свежих котировок), на который он попал при установке. Есть скрипты, которые с функцией while() могут находиться на графике до момента его закрытия, либо перезагрузки терминале, но сейчас речь не о них.

Зачем же нужен скрипт? Это простая программа, но применений ей много. Из самого простого скрипт может изменить цвет или масштаб графика, вид отображения свечей, выдать текущий спред или цену Open/Close, High/Low заданного количества баров, а также открыть или закрыть существующий график. Из более сложного: рассчитать безубыток открытых позиций, суммарный лот ваших ордеров, их количество, направление и отобразить цели. Может открыть, модифицировать или закрыть существующие ордера трейдера по заведомо заданным настройкам, записать котировки в отдельный файл на диске, закрыть терминал и т.п. Проще говоря — скрипт mql4 может выполнить любое действие, которое не требует его постоянного нахождения на графике. Выполнил и удалился.

Чтобы создать скрипт, нужно в меню нажать ‘Файл’ -> ‘Создать’. Выбираем пункт ‘Скрипт’, жмем далее.

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

Назовем свой первый файл 1.0 Hello World. Автора и ссылку можно оставить по умолчанию, это не имеет сейчас значения и по желанию в самой программе это можно всегда изменить. Внешние переменные скрипта мы задавать не будем, в данном примере они не нужны, плюс их можно указать потом. Жмем ‘Готово’.

Перед нами появился экран кода данной программы. Рассмотрим его подробнее.

С 1 по 5 строку идет текстовая запись — комментарии, это можно понять по двух наклонным линиям //
Это означает, что данный текст не учитывается в коде программы и виден только программисту, это свое рода напоминание, подсказка. Данные комментарии нужны в коде, чтобы по началу в нем просто не потеряться, о чем я говорил в предыдущем посте.

Далее с 6 до 9 строчку идет свойство программа #property. Оно задается один раз для всей программа. Свойства бывают разные и отличаются для скриптов и индикаторов. В данном примере свойства простые и отображают ту информацию, что мы указали при создании скрипта. А именно:

• copyright — наименование компании или программиста, который создал эту программу.
• link — ссылка на веб сайт разработчика, можете указать свой сайт или ссылку на профиль MQL5.Community.
• version — текущая версия программы. По умолчанию 1.0, далее пользователь уже сам увеличивает версию по мере модификации кода.
• strict — параметр строгой проверки на ошибки, он просто должен быть прописан, чтобы программист не упустил какие-то недочеты в коде во время компиляции. В ранних версиях MetaEditor данного параметра не было, код мог содержать сотни ошибок, в основном неявных преобразований переменных.

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

То есть запись свойства идет в такой последовательности: свойство — пробел — константа — пробел — в кавычках описывается текст.

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

Теперь информация о программе будет отображаться таким образом:

Поскольку нам не нужно сейчас настраивать внешние переменные скрипта и видеть информацию о программе, мы закомментируем строчку script_show_inputs, поставив две наклонные линии // в самом начале строки чтобы данная строчка не учитывалась при компиляции и выполнение программы было сразу после запуска. Теперь свойства выглядят так:

Чтобы посмотреть, какие еще бывают свойства, можно воспользоваться справкой. Для этого поставить текстовый указатель на слово property и нажать F1. Справка очень полезная вещь, к которой вы будете постоянно обращаться, чтобы найти нужные функции, переменный и примеры их использования.

Оставшаяся часть кода это функция обработки событий OnStart(), которое является заголовком функции.

Именно в ней происходит выполнение кода скрипта, данная функция не имеет параметров и используется только для скриптов. Тип переменной void обозначает, что данная функция не возвращает никаких значений, т.е. по завершению работы она не будет запоминать и выдавать результат, в ней не используется оператор return.

Функции для обработки событий бывают разные для разных типов кода, они определены программой MQL4 и не подлежат изменениям. Основные из них создаются автоматически, другие дополнительно указываются пользователем при создании советника, скрипта, индикатора или библиотеки.

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

Функция Print

Переходим к самому основному, для чего эта тема и создана — напишем «Привет Мир!«

Любое информационное сообщение пользователя в журнале терминала выводиться через общую функцию Print(). Она также является типом void, в круглых скобках же указывается наше сообщение. Разместить функцию нужно между фигурными скобками OnStart. Для завершения функции Print, чтобы сказать программе, что мы закончили с ней работу, нужно поставить точку с запятой ;

Все, после этого компилируем советник (создаем .ex4 файл), нажав на кнопку на панели инструментов, либо на F7.

Полученный скрипт автоматически должен появится в окне Навигатора во вкладке ‘Скрипты’. Если этого не произошли — кликаем правой клавишей по данной вкладке — ‘Обновить‘. Скрипт переносим на любой график валютной пары и проверяем журнал:

Журнал читается снизу вверх. Мы видим, что вначале скрипт был загружен (loaded successfully), инициализирован (initialized), после этого вступила в работу функция OnStart, в которой выполнило свое действие всего одна заданная нами функция Print, что дало нам увидеть сообщение: «Hello World«. После этого скрипт деинициализировался, т.е. завершил свой работу (uninit reason 0) и удалился с графика (removed).

Все оказалось просто. Через принт можно выводить данные любых текстовых значений и переменных (кроме массивов, они выдаются поэлементно) длиной до 64 символов. Типы переменных мы рассмотрим в следующем уроке.

Принтов в коде может быть сколько угодно, по началу даже лучше, если их больше и они информационные.

Раз мы начала изучать функции вывода информации, то почему бы быстренько не рассмотреть их все.

Другие функции вывода информации:

• Comment — функция, которая выводит mql4 комментарии в левый верхний угол графика, на котором запущен скрипт. Тип ее также void. Длина комментария намного больше, чем Принта — 2045 символов. В основном комментарий используется для наглядного отображения информации непосредственно на графике, я его использую для вывода настроек советника, текущего спреда, цены и т.д.

Обработка кода редактором идет сверху вниз внутри одной функции. Пишем ту же самую надпись сразу под функцией Print:

Компилируем, запускаем скрипт и проверяем график:

Как видно, принт и наш комментарий отобразился. Вначале скрипт обработал функцию принт, затем комментарий.

Чтобы разделить комментарий на несколько строк, нужно использовать символ перевода строки «n». Проверьте, как теперь будет выглядеть надпись.

Из минусов комментария можно отметить только два — нельзя регулировать размер и тип шрифта, а также его нельзя вручную стереть с графика.

• Alert — отдельно всплывающее диалоговое окно с данными пользователя. Alert в mql4 также можно разделять на несколько строк с помощью текстового разделителя «n». Длина его 64 символа, а тип void. Нужен он в основном, чтобы сигнализировать пользователю о данных индикаторов, когда цена перешла какую то отметку, либо о сигнале входа в рынок. Алерт сопровождается звуковым сообщением, который можно отключить в настройках. Чтобы установить алерт в программе мт4 необходимо прописать всего одну строчку:

• MessageBox — окно сообщений, чем то схоже с Алертом, но больше напоминает информационные окна Windows. Имеет ряд настроек, таких как Заголовок окна, флаги для создания дополнительных кнопок и иконок этого окна. Тип данной функции int, т.е. она возвращает целое число после своего выполнения.

Функция MessageBox содержит в себе три параметра, но мы можем указать только первый — текст:

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

Функция редко примеряется мною в коде, но с помощью нее можно создать ряд всплывающих окон для подтверждения каких либо действий, вот пример, накиданный на скорую руку, возможно где-то такой пример вам пригодится. Попробуйте проверить его работу.

• SendNotification — функция отправки сообщения на мобильный телефон или планшет в приложение Meta Trader 4. Для корректной работы вы заранее должны указать свой MetaQuotes ID в настройках терминала. Имеет всего один текстовой параметр, длина сообщения не должна превышать 255 символов.

• SendMail — функция отправки текстового сообщения на электронную почту. Для корректной работы нужно настроить в терминале сервер SMTP, к примеру для Яндекс: smtp.yandex.ru:25, для Mail.ru: smtp.mail.ru:465. Функция имеет 2 параметра — заголовок письма и текст.

Заключение 

На сегодня это все. Я рассказал, как сделать алерт в мт4 и попытался максимально просто, в доступной форме описать самые простые функции для вывода сообщений пользователя на экран и работу в программе MetaEditor, т.к. функции mql4 Print и Comment будут очень часто использоваться нами в дальнейшем.

Прикладываю ссылку на файл .mql4 с данными функциями ниже.

Если у вас будут вопросы — пишите комментарии.

Как написать скрипт для работы на форекс

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

Существует два типа скриптов, а именно торговые и аналитически. Торговые скрипты являются самыми распространенными и часто применимыми, поскольку они решают торговые задачи.

Вам необходимо выставить сеть отложенных ордеров, удалить несработанные ордера или моментально закрыть все сделки без лишних телодвижений, а может перевернуть позицию или открыть удвоенным лотом?

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

Для примера вы хотите нанести уровни поддержки и сопротивления, сетку Фибоначчи или другие элементы технического и графического анализа? Именно с этими задачами справляются такого рода скрипты.

Написание скрипта

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

Определившись с четкой задачей и функциями будущего скрипта, следующим шагом является его реализация. Реализовать или написать свой скрипт можно только двумя путями, а именно заказать разработку у специалистов, которые разбираются в программировании или написать самостоятельно через специальный встроенный редактор в торговом терминале Metaquotes.

Если вы разбираетесь в программировании или решили с помощью учебника написать свой первый скрипт, запустите редактор с помощью специального значка на панели инструментов МТ4 либо нажав клавишу F4. После того как перед вами появится редактор в левом верхнем углу нажмите на кнопку «Создать».

Введение

Совет

Первое знакомство с 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;
Ещё один элемент языка — комментарии. Если вы напишете «//»

перед строкой, то она целиком закомментируется. Это значит,

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


Теперь вы должны заметить, что код пустого скрипта включает

в себя много комментариев, которые несут информативный характер.

Комментируйте свой код, иногда это может сэкономить вам много

времени.

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

того, как мы их объявили. Рассмотрим простой пример:
double a = 50.0;
                
double b = 2.0; 
double c;   

c = a + b;      
                
                

c = a - b;      
c = a*b;        
c = a / b;      
c = (a + b)*a;  
                
                
                

c = (a + b) / (a - b); 
                
c = a + b*3.0;  
                
Если нужно выполнить какую-то операцию с переменной и присвоить

ей же результат, например, увеличить на 5, то поступают одним

из следующих способов:
int a = 5;
a = a + 5;  
a += 5;     
a = a*5;
a *= 5;     
a /= 5;     
Если хотите увеличить или уменьшить переменную на 1, используйте

такой метод:
int a = 5;
a++;  
а--;  

Это всё очень хорошо, но вы при выполнении подобных скриптов

можете только догадываться, правильно всё работает или нет,

так как на экране ничего не происходит.

 Поэтому удобно выводить результаты. Для этого существует встроенная

функция 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; 


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];   
                  
price[0] = 1.2341; 
                   
                   
                   
                   
 
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;
 
int a=0;
 
AveragePrice+=High[a];
a++;              
                  
                  
 
AveragePrice+=High[a];
a++;                   
 
AveragePrice+=High[a];
а++;                   
 


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

ещё несколько моментов.
Условие выполнения цикла может быть другим. Например, таким:
a>10    
a!=10   
a==20   
a>=2    
a<=30   
Изменение счётчика может производиться и по-другому. Например,

вам необязательно увеличивать его каждый раз на 1. Вы можете

поступить иначе:

a--     
a += 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? Вот пример:
if( у меня будет достаточно времени )   
  {  
    
    то дочитаю эту книжечку; 
  }


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) 
               
               
{
   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, а также ознакомимся

с другими встроенными функциями, которые предоставляют огромные

возможности для программирования.

Содержание:

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

2. Исходный код и компиляция программы

3. Переменные MQL4

4. Комментарии в коде программы MQL4

5. Работа с переменными в MQL4

6. Функции MQL4

7. Массивы в MQL4

8. Предопределенные массивы и переменные MQL4

9. Оператор цикла for

10. Условный оператор if … else

11. Функция Print()

12. Операторы сравнения в MQL4

13. Логические операции && и ||

14. Группировка условий

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

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

• Скрипты — это последовательности команд, программ, которые работают только один раз согласно вашей команде. Они могут заменить повседневные действия в терминале. Например, разместить ордера на покупку или продажу. Они также могут выполнять определенные действия — например, анализировать графики и генерировать информацию.

• Собственные индикаторы — это технические индикаторы, написанные пользователем в дополнение к тем, которые уже есть в терминале. Они отображают графики или другую визуальную информацию. В отличие от скриптов, индикаторы запускаются всякий раз, когда меняется цена, то есть на каждом тике. Они могут сообщить о ситуации на рынке, дать совет по покупке или продаже. То, какие индикаторы будут отображаться, будет зависеть только от вас.

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

• Библиотеки — это наборы функций для выполнения конкретных задач. Например, одна из ваших автоматизированных стратегий может использовать специальные математические функции при решении, когда продавать, а когда покупать.

Все эти программы мы напишем в специальном редакторе — MetaEditor 4 . Чтобы использовать его, вы должны сначала установить терминал MetaTrader 4 (MT4), который можно загрузить здесь. После его установки вы увидите окно терминала на мониторе, которое будет выглядеть следующим образом (рис. 1).

Если вы хотите изменить язык терминала на русский, то в строке меню нажмите на вторую вкладку «Вид» , затем наведите курсор мыши на «Языки» , в раскрывающемся списке выберите «Русский», и после перезапуска терминала язык будет изменен.

Чтобы запустить MetaEditor 4, в открытом терминале на клавиатуре нажмите F4 или в строке меню нажмите «Сервис», а затем Редактор языка MQL4 или нажмите специальный значок в терминале

• Может возникнуть вопрос, а можно ли установить MetaEditor 4 без необходимости установки MT4? 

Нет. Он является неотъемлемой частью терминала и не будет работать без него. 

• Также может возникнуть второй вопрос: можно ли использовать другие редакторы для создания программ для MT4? 

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

После запуска MetaEditor 4 появится окно этого редактора

Чтобы изменить язык на русский, нажмите на вкладку «Вид» в строке меню , наведите курсор мыши на «Языки» , нажмите на «русский» в раскрывающемся списке, и после перезапуска язык будет установлен на «русский». Чтобы создать новую программу, нажмите кнопку «Создать» в верхней левой части редактора или нажмите Ctrl + N на клавиатуре

Появится окно, в котором вы должны выбрать тип программы, которую хотите создать. Выберите «Скрипт» и нажмите «Далее»

В следующем окне в поле «Имя» введите имя сценария, например, «Тест» . При желании вы можете ввести свое имя в поле « Автор» , а также  заполнить поле  «Ссылка»

После нажатия кнопки «Готово» появится окно с исходным кодом. Видите ли, даже пустой свежеиспеченный скрипт уже содержит некоторый код. В окне «Навигатор» , которое находится в левой части редактора на рисунке 8 ниже, вы можете видеть, что этот файл скрыт в папке с именем Scripts.

Если вы хотите найти этот файл на жестком диске, щелкните правой кнопкой мыши имя файла в окне навигатора и выберите «Открыть папку» (рис. 9). Если навигатор исчез какой — то причине, он вызывается нажатием кнопки в строке меню «Вид» -> «Навигатор»  или комбинацию клавиш Ctrl + D .

Теперь все готово для написания программ на MQL4.

Исходный код и компиляция

После создания нового скрипта, как мы делали в предыдущей части статьи, вы можете видеть, что он уже содержит некоторый код.

В строках с 1 по 5 после символов двойной косой черты // есть комментарий. Собственно комментарий и обозначается //

 Записи Test.mq4 — это имя файла и его тип, остальное — это информация, которая была сохранена при создании файла. 

Далее, в строках с 6 по 9, вы можете увидеть четыре записи, которые начинаются со слова #property. Это так называемая директива препроцессора. Эта запись определяет некоторые свойства будущей программы. При создании сценария были добавлены четыре директивы, которые содержат четыре свойства: 

• авторское право — автор программы, 
• ссылка- ссылка на сайт автора. 
• Следующее свойство version является версией программы. При создании новой программы версия «1,00» будет введена автоматически . 
• Четвертое свойство strict — очень важный элемент программы.  #property strict подтверждает использование компилятора MQL4.

Прежде чем начать писать какую-либо программу, вы должны понять одну очень важную вещь. В MetaEditor 4 вы пишете исходный код, то есть последовательность команд, которые будут выполняться одна за другой. Однако терминал не может работать напрямую с исходным кодом. Такой код понимает человек, но не MetaTrader 4. Чтобы его понимал терминал, он должен быть «переведен» на машинный язык. Для этого на клавиатуре, нажмите F7 или меню панели, щелкните мышью на пункте меню «Файл»  а затем «Компилировать» или сразу нажать на иконку «Компилировать».

Компиляция — это процесс преобразования файла, содержащего исходный код с расширением * .mq4, в файл с расширением * .ex4, который будет понят MetaTrader 4.

Чтобы немного сократить код без ущерба для его функциональности, удалите комментарии и первые 3 директивы препроцессора. Оставьте #property strict и основную функцию сценария void OnStart ()  и нажмите компилировать. 

#property strict 
void  OnStart () 
  { 
// ---

   }

Если вы сейчас перейдете в папку с файлами сценариев, вы найдете там два файла наших сценариев тестирования: Test.mq4 — файл исходного кода и Test.ex4 — скомпилированный файл

Хорошо, у нас уже есть файл, который можно проверить в MetaTrader 4. Вернитесь к терминалу сейчас. В навигаторе вы можете увидеть четыре основные папки: счета, индикаторы ,советники и скрипты. Если по каким — либо причинам окно навигатора вы не видите в терминале, в строке меню нажмите Вид, а затем выберите «Навигатор» или  нажмите сочетание клавиш Ctrl + N .

Слева от скриптов, нажмите на плюс, чтобы раскрыть содержимое этой папки. Найдите там тестовый файл и, чтобы запустить его, дважды щелкнув на его имя или перетащите его на график. Ничего не произойдет, потому что скрипт пуст. Если вы щелкнете по имени скрипта только один раз, выбрав его, а затем нажмете Enter на клавиатуре, MetaEditor 4 откроется с исходным кодом при условии, что файл Test.mq4 присутствует в папке Scripts.

Теперь вы знаете, каков процесс написания программы на mql4:

1. вы пишете исходный код

2. компилируйте программу

3.  запускаете программу в терминале мт4

4. смотрите на результат

5. если нужно, исправляете код

   1. компилируете

   2.  … и так до тех пор, пока не получите желаемый результат.

Переменные MQL4

Что такое переменная? Попробуйте ответить на этот вопрос самостоятельно, и я вам помогу. Сколько вам лет? Сколько вам будет через пять лет? Ваш возраст — просто переменная. Другими словами, его первой характеристикой является изменчивость.

Другой пример, какой был ваш рост в возрасте двух лет? Вероятно, намного меньше, чем сейчас, Рост является еще одним примером переменной. Но есть важное отличие. Мы обычно измеряем возраст, используя целое число. Рост гораздо проще измерить в десятичных числах. Например, возраст — 20 или 25 лет, рост — 1,80 или 1,95 м.

В MQL4 каждая переменная имеет определенный тип.

Теперь мы научимся правильно создавать переменные в MQL4. Посмотрите на код ниже.

//код 1
#property strict

int age = 25;

void OnStart()
  {
//---

  }

До того, как была написана основная функция скрипта OnStart (), мы написали:

int age = 25;

Что сделает компьютер, когда увидит это? Во-первых, в оперативной памяти ОЗУ будет зарезервировано место, где будет храниться номер:

•  int-это ключевое слово языка MQL4, обозначающее целое число (integer).
• age-это имя переменной, то есть слово, с помощью которого компьютер будет получать это число.

Затем для age в RAM будет записано число 25, используя символ уравнения =, и вся эта конструкция закрывается символом точки с запятой;

В MQL4 схема создания переменной, определения ее типа и присвоения значения выглядит следующим образом:

тип переменной имя переменной = значение переменной ;

Если вы сохраните только тип и имя переменной, т.е. создадите ее только в ОЗУ, это действие будет называться объявлением переменной. В этом случае этой переменной будет присвоено нулевое значение по умолчанию. Но если программист сразу назначит ей конкретное значение, например, как в приведенном выше примере, число 25, то эта переменная будет называться инициализированной. 

В этом примере мы видим 3 шага:

• определение типа переменной:   int ,
• присвоение имение переменной:   age
• присвоение ей значения:   25 .

Все это называется инструкцией. Здесь три действия были выполнены в одной инструкции, а точка с запятой обозначает конец этой инструкции.

Не забудьте написать точку с запятой в конце каждого оператора.

Этот код также можно написать по-другому, поместив инструкцию для создания переменной в теле основной функции, то есть в скобках { и }

• Слово void определяет тип функции — это пустой тип. 
• OnStart — это имя функции. 
• В скобках функции () сохраняются конкретные значения, на основании которых она выполняет действия (в этой функции ничего не сохраняется). 
• Скобки {} определяют область действия функции (т. н. тело функции) и то, что будет сохранено в них, будет реализовано OnStart().

//код 3
#property strict
void OnStart()
  {
//---

   int age = 25;

  }

Коды 1 и 3 будут работать одинаково. Создание переменной перед или внутри функции, то есть между {}, влияет на доступность переменной в программе. В первом примере она будет доступен для всей программы, а не только для функции OnStart (). 

Во втором  — она будет виден только внутри этой функции. Теперь вам может быть трудно переварить информацию, поэтому сейчас мы примем принцип, согласно которому в скриптах мы обычно создаем переменные перед OnStart () , и мы уже будем описывать различные типы действий в теле этой функции.

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

double height = 1.95;

Здесь мы создали переменную типа double (десятичная дробь, число с плавающей запятой, floating-point number), дали ей имя height, которому сразу же присвоили значение 1.95, используя оператор уравнения =. А что в самом конце? Да, там стоит точка с запятой.

Какие еще типы переменных существуют в MQL4? Существует текстовый тип. Как следует из названия, он используется для хранения текста.

string name = "Важное сообщение";

Здесь string (строка) -тип переменной, name-имя переменной, а «Важное сообщение» — значение этой переменной. Обратите внимание, что текст должен быть сохранен между двумя кавычками «».

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

bool trend = false;

В дополнение к этим четырем типам переменных есть много других типов. Поскольку вы только изучаете Программирование на mql4, то предлагаем вам пока ограничиться знанием этих четырех основных типов.

В MQL4 очень важно, пишете ли вы ЗАГЛАВНЫМИ или строчными буквами. Например, если вы объявляете несколько переменных с одинаковыми именами, но используете буквы разного размера, то это будут совершенно разные переменные. Приведенный ниже код создаст четыре переменные типа double.

double height; 
double HEIGHT; 
double Height; 
double HeighT;

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

DOUBLE height; 
Double height;
doublE height;

! Этот код не будет работать, потому что слова DOUBLE, Double и doublE не будут рассматриваться компилятором MQL4 как ключевые слова.

MQL4 — это регистрозависимый язык.

Имена переменных не могут начинаться с цифры. Они не могут содержать специальные символы (@, &,%, $, …), точки, знаки минус, знаки плюс, умножение и деление. Следующий код содержит недопустимые имена переменных.

double 1price;    
double %price;    
int    Star-Wars; 
bool   Mario@2;   
string bla.bla; 

Имена переменных могут состоять из строчных и заглавных букв a-z, A-Z, цифр 0-9 и символа подчеркивания _ , а длина имени не должна превышать 63 символов.

Некоторые примеры правильно сохраненных имен переменных (код 10).

double p1rice;
double price;
int    Star_Wars;
bool   Mario255H;
string blabla;

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

int age;       double height       =1.95; 


string    name
=
"Важное сообщение"

                    ;

Этот код будет работать правильно! Но давайте напишем этот код, как настоящие профессионалы.

int    age;
double height = 1.95; 
string name   = "Важное сообщение";

Если мы хотим создать (объявить) более 1 переменной одного типа, мы можем сделать это в одной инструкции. Некоторым из них могут быть сразу назначены (инициализированы) определенные значения без того, чтобы все эти переменные были в одной строке. Их имена должны быть разделены запятой и в конце ставить точку с запятой в качестве символа для конца инструкции. В приведенном ниже примере (код 13) компьютер в оперативной памяти зарезервирует место для 7 переменных типа int и 2 переменных типа double . С помощью этой переменной age и таблицы сразу назначат значения 25 и 3 .

int age = 25, number, tables = 3,
    Houses, houses, HOUses,
    result;

double height, weight;

Комментарии в коде программы MQL4

Комментарии являются еще одним полезным элементом в программировании. С их помощью вы можете создать своеобразную заметку в исходном коде, которая улучшает качество его понимания и намерения программиста. Если вы напишите символ двойной косой черты справа // (двойная косая черта), текст в строке справа будет прокомментирован . Это однострочный комментарий . Если вы хотите написать более крупный комментарий, введите текст между / * и * / . Эти символы могут быть в разных строках. Это многострочный комментарий . Комментарии не влияют на работу программы, потому что они игнорируются во время компиляции.

// это однострочный комментарий 
int     age = 25 ;   // это однострочный комментарий 
double height = 1 , 95 ; // это однострочный комментарий 

string name = "Down Crumbs" ; 
/ * 
это 
многострочный комментарий 
* /

Если символы комментария // или / * и * / вы наберете между кавычки «» внутри строковой переменной, то текст не будет возможности комментировать (код 2).

// это комментарий
string name = "это // не комментарий"; //Это комментарий

/* это комментарий */
string name = "это /* не */ комментарий"; /* Это комментарий */

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

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

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

# Property strict

double A = 50.0; // объявляем переменную a десятичным числом и инициируем его значением 50.0

double B = 2.0; // объявляем переменную B десятичным числом и инициализируем его значением 2.0

double C; // мы просто объявляем переменную C по умолчанию C будет равна 0.0

void OnStart () // основная функция скрипта
{
//---
C = A + B; / * мы присваиваем переменной c сумму переменных
A и B. теперь C равно 52.0
Как и после любой другой инструкции
нужно сохранить точку с запятой */

C = A-B; // вычитание, C = 50.0-2.0 = 48.0
C = A * B; // умножение, C = 50.0 * 2.0 = 100.0
C = A / B; // деление, C = 50.0 / 2.0 = 25.0

C = A + B* A; / * по правилам математики сначала
мы получим значение умножения B на A, затем
мы добавим к A и назначим результат переменной C
C = 50.0 + 2.0 * 50.0 = 50.0 + 100.0 = 150.0 */

C = A + B/A - B; // C = 50.0 + 2.0 / 50.0 - 2.0 = 50.0 + 0.04 - 2.0 = 48.04

C = (A + B) * A; /* в скобках нужно размещать операции, которые должны быть сделаны в первую очередь. В этом случае сначала мы получим сумму A и B, затем эта сумма он будет умножен на A и назначена переменной C
C = (50.0 + 2.0) * 50.0 = 52.0 * 50.0 = 2600.0 */

C = (A + B) / (A - B); // C = (50.0 + 2.0) / (50.0 - 2.0) = 52.0 / 48.0 = 1.083333333333330
}

В этом коде перед OnStart() мы создали 3 переменные a, B и C типа double и сразу A и B присвоили определенные значения. Затем в теле основной функции сценария мы записали математические действия. Справа, используя символы комментария / / и /* … * / мы описали эти действия.

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

# Property strict

int a = 10; // объявляем переменную a целым числом и присваиваем ей 10

void OnStart () // основная функция скрипта
{
//---
A = a + 5; // мы увеличиваем A на 5 и присваиваем a результат, A = 10 + 5 = 15
A += 5; // начальное значение A увеличивается на 5, a = 15

A = a-5; / / мы уменьшаем A на 5 и присваиваем a результат, A = 10-5 = 5
A - = 5; // начальное значение A уменьшаем на 5, a = 5

A = a * 5; // умножаем A на 5 и присваиваем a результат, A = 10 * 5 = 50
A * = 5; // начальное значение A умножаем на 5, a = 50

A = a / 5; // мы делим A на 5 и присваиваем a результат, A = 10 / 5 = 2
A / = 5; // начальное значение A делим на 5, a = 2
}

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

#property строгого 

INT А = 10 ; 
void  OnStart () 
  { 
// ---
    A ++;   // увеличиваем A на 1 (с приращением), A = 10 + 1 = 11
    A--;   // уменьшить A на 1 (уменьшение), A = 10 - 1 = 9
   }

В этом примере запись A ++ идентична в своей работе записям  A = A + 1 и A + = 1 . Обозначения A— идентичны позициям A = A — 1 и A — = 1 . Далее рассмотрим, как выводить результаты расчетов на монитор.

Функции MQL4

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

Для вызова функции сначала нужно написать ее имя. Не забывайте о регистре! MetaEditor 4 имеет очень полезный механизм для подсказки имен функций и других ключевых слов после написания первых 3 букв (при настройке редактора по умолчанию). Среди прочего, поэтому мы призываем вас писать программы на MQL4 именно в этом редакторе. Для отображения текста на мониторе теперь мы будем использовать Alert().

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

Теперь просто введите левую круглую скобку после имени функции ( . В этот момент появится другое приглашение относительно типа функции и аргументов, которые она может принимать.

Как вы можете видеть из этой подсказки, Alert () имеет тип void (пустой тип). Ранее мы уже познакомились с другой функцией onStart () типа void. Разница между ними заключается в том, что OnStart () является основной функцией скрипта, и без нее скрипт вообще не будет работать. В исходном коде перед каждой основной функцией всегда нужно писать ее тип.

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

В MQL4 каждая функция имеет определенный тип.

В области подсказки между скобками мы видим многоточие … . Что это значит? На клавиатуре теперь нажмите Esc, чтобы всплывающее окно подсказки исчезло. Затем переместите курсор куда-нибудь в центр слова Alert и нажмите F1. Появится справка редактора с описанием свойств этой функции.

Из этого описания можно сделать вывод, что после открывающей скобки должны быть записаны аргументы, разделенные запятыми, а после закрывающей скобки точка с запятой. Мы также видим, что для функции Alert () количество аргументов не должно превышать 64. Так вы можете найти такую ​​полезную информацию для каждого зарезервированного слова MQL4. Еще одним источником информации об этой функции и всех других важных элементах этого языка программирования является учебник по mql4, который можно скачать бесплатно или официальный веб-сайт MQL4 .

Вариант 1. В заголовке функции Alert () , то есть в скобках, введите один аргумент — текст «Мой первый скрипт работает» .

// вариант 1 
#property strict 

void OnStart()
  {
//---
 Alert ("Мой первый скрипт работает"); 
   
  }

Скомпилируйте этот код, перейдите в MetaTrader 4, в панели навигатора дважды щелкните имя скрипта или перетащите его в окно цитаты и отпустите его. Появится окно сообщения.

Отлично! Ваша первая программа, написанная на MQL4, работает! Ниже покажем еще несколько примеров того, как вы можете получить тот же результат.

// вариант 2
#property strict

void OnStart()
  {
//---
   Alert("Message" , 35 , " lat");
  }

Второй аргумент — математическая операция 2020 — 1990 гг. Это приемлемо в MQL4.

// вариант 3
#property strict

void OnStart()
  {
//---
   Alert("Message " , 2020 - 1990 , " lat");
  }

Вариант 4. Перед основной функцией были объявлены 3 переменные: YearOfBirth , YearNow и Age . Первым двум были сразу присвоены значения, соответственно 1990 и 2020 . Затем, в теле основной функции, сначала переменной Age была присвоена разница первых двух переменных ( Age = YearNow — YearOfBirth ), а затем Age была передана в заголовке функции Alert () вместо второго аргумента.

#property strict

int YearOfBirth = 1990;
int YearNow     = 2020;
int Age;

void OnStart()
  {
//---
   Age = YearNow - YearOfBirth;
   Alert("Message " , Age , " lat");
  }

Вариант 5. Перед основной функцией OnStart () в одной инструкции были объявлены 2 переменные YearOfBirth и YearNow. В теле этой функции этим переменным были присвоены значения соответственно 1990 и 2020. Следующим вместо второго аргумента в заголовке Alert () была математическая операция: YearNow — YearOfBirth . Также обратите внимание, что аргументы в заголовке Alert () не записаны в одной строке, и в этом нет ошибки.

// вариант 5 
#property strict 

int YearOfBirth, YearNow; 

void  OnStart () 
  { 
// ---
    YearOfBirth = 1990 ; 
   YearNow = 2015 ; 

   Alert ( "Message" , 
         YearNow - YearOfBirth, 
         "lat" ); 
  }

На этих примерах хорошо видно разнообразие языка MQL4. Как видите, каждая программа может быть написана разными способами. Здесь мы имели дело с очень простым сценарием, поэтому достаточно применить только его первый вариант, и в случае изменения содержания сообщения Вы можете легко найти место для исправления. В случае, если бы мы работали с кодом, который насчитывал бы несколько тысяч строк и более, где было бы много переменных, каждая из которых была бы использована много раз, тогда лучше создать переменную в самом начале, присвоить ей значение и в случае каких-либо изменений, просто в одном месте, присвоить ей новое значение, чем всему коду искать все места, где это значение встречается. При таком подходе вариант 4 или 5 хорош.

Массивы MQL4

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

Давайте вместе рассмотрим следующий пример. В память компьютера нужно положить 5 цифр, которые мы позже будем использовать для расчетов. Как сделать Вы можете создать 5 переменных отдельно и присвоить им значения.

#property strict

double price_Bartek = 1.2341,
       price_Kasia  = 1.2321,
       price_Michal = 1.2361,
       price_Magda  = 1.2411,
       price_Benek  = 1.2301;

void OnStart()
  {
//---
   
  }

Здесь в пределах одного оператора создаются 5 переменных типа double и им присваиваются числовые значения. Вы можете сделать по-другому, используя один массив

#property strict 

double price_Friend [5];      // объявление массива, состоящего из 5 элементов 

void  OnStart () 
  { 
// ---
    price_Friend [0] = 1.2341 ; // мы присваиваем значение первому элементу массива 
                             // с индексом ноль [0]. 
   price_Friend [1] = 1,2321 ; 
   price_Friend [2] = 1,2361 ; 
   price_Friend [3] = 1,2411 ; 
   price_Friend [4] = 1,2301 ;
  }

Здесь перед основной функцией OnStart () был объявлен массив, а затем в теле функции каждому элементу массива было присвоено соответствующее числовое значение. Объявление массива в этом примере выглядит следующим образом:

double price_Friend [5];

Чтобы создать массив, сначала укажите его тип (double), затем его имя (price_Friend), затем в квадратных скобках укажите количество элементов этого массива [5] и, наконец, введите точку с запятой. В MQL4 схема создания массива выглядит следующим образом:

• тип массива имя массива [ количество элементов  массива];

 Объявление массива отличается от объявления переменной только тем, что вам нужно записать количество элементов после имени в квадратных скобках [] . В нашем примере массив будет содержать 5 элементов.

До OnStart () мы определили тип массива как double , и каждый из его элементов также будет иметь этот тип. Присвоение значения элементу массива отличается от присвоения значения переменной только тем, что должен быть записан индекс [] соответствующего элемента массива.

price_Friend[0] = 1,2341 ;

Теперь мы подошли к очень важной вещи, которую нужно запомнить.

В массивах индексация элементов начинается с нуля [0] , а не с одного [1] !

В нашем примере массив с именем price_Friend состоит из 5 элементов: первый имеет индекс 0, второй имеет индекс 1, а последний пятый элемент имеет индекс 4 в массиве .

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

#property strict 

void  OnStart () 
  { 
// --- 
   string word [2]; // объявление типа строки text 'string', 2 ​​элемента 
   int year [2]; // объявление типа целочисленного массива 'int', 2 элемента 

// --- присвоение значения элементов элементам

   word[0] = "Mam "; word[1] = " lat";
   year[0] = 1990;   year[1] = 2015;

// --- отображаем результат

 Alert( word[0] , year[1] - year[0] , word[1] );
  }

В коде выше мы сначала объявили 2 массива, а затем в отдельных инструкциях мы присвоили элементам значения этих массивов. В MQL4 один оператор может использоваться для объявления массива и немедленного присвоения значений его элементам. Тогда вы не сможете ввести количество элементов в квадратных скобках и записать значения через запятую после знака уравнения в скобках {} . На основе количества значений компилятор автоматически определит количество элементов массива и зарезервирует для них место в оперативной памяти.

#property strict 

void  OnStart () 
  { 
// --- 
   string word [] = { "Мне сейчас" , "лет" }; // объявление и инициализация массива слов 
   int     year [] = { 1990 , 2020 };     // объявление и инициализация массива года 

// --- отображение результата 
   Alert (word [ 0 ], year [ 1 ] - year [ 0 ], word [ 1 ]); 
  }

В этом коде для массива word компилятор создаст 2 элемента, потому что в скобках мы сохранили 2 значения: «Мне сейчас» и » лет». Первому элементу, т. е. word[0], компилятор назначит значение «Мне сейчас», а word[1] будет иметь значение «лет». Таким же образом компилятор будет обрабатывать массив year.

Выбегая немного вперед, скажем, что массивы могут иметь те же типы, что и переменные. Они могут быть не только одномерными, как в нашем примере, но и многомерными (максимум 4 измерения). Есть статические и динамические массивы, и есть несколько способов их инициализации.

Предопределенные массивы и переменные MQL4

Когда в MetaTrader 4 запускается MQL4-программа (скрипт, индикатор или советник), в памяти компьютера автоматически создаются определенные предопределенные переменные и предопределенные массивы . Например, предопределенная переменная _Symbol хранит имя финансового инструмента окна котировки, в котором был запущен MQL4. В свою очередь, предопределенная переменная _Digits хранит количество символов после десятичной точки, которые определяют точность измерения цены этого финансового инструмента (символа).

В ранее созданном скрипте с именем Test введите следующий код:

#property strict 

void  OnStart () 
  { 
// --- 
   Alert ( "Symbol =" , _Symbol , 
         ". Точность измерения цены =" , _Digits , " символа." ); 
  }

Скомпилируйте скрипт, а затем в MetaTrader 4 запустите его, например, на EURUSD.

Обратите внимание, что нигде в коде выше мы не объявляли ни _Symbol, ни _Digits, и все же скрипт правильно определил название финансового инструмента (EURUSD) и количество знаков после запятой (5).Благодаря тому, что программы, подготовленные на MQL4, могут сами создавать некоторые переменные, это облегчает работу программиста. Существует много таких предопределенных переменных, и мы думаем, что по мере того, как ваши программы станут больше, вы оцените их полезность.

Для лучшего понимания предопределенных массивов, давайте вспомним, какую информацию содержат японские свечи. Наведите курсор мыши на правую свечу для любого символа (на рисунке ниже 2 это GBPUSD, интервал времени 30 минут (M30)), чтобы появилась подсказка.

Здесь мы видим шесть значений:

• время создания свечи (Time),
• цена ее открытия (Open),
• самая высокая цена (High),
• самая низкая цена (Low),
• цена закрытия (Close)
• количество тиков (Volume). 

Как получить эти данные с помощью MQL4? Они хранятся в следующих предопределенных массивах: Time [] , Open [] , High [] , Low [] , Close [] и Volume [] .

В разделе, посвященном массивам, мы подчеркнули, что индексация элементов массивов начинается с нуля [0]. Для котировок текущая свеча, т. е. первая справа, имеет индекс 0. Слева от него есть индекс 1 и т. д. Посмотрите на рисунок ниже.

Ниже скрипт, который покажет нам цены Open, High, Low и Close свечи с индексом 3.

#property strict

void OnStart()
  {
//---
   Alert("Свеча с индексом " , 3,
         " цена Open = " , Open[3],
         " цена High = " , High[3],
         " цена Low = " , Low[3],
         " цена Close = " , Close[3]);
  }

После запуска этого скрипта в окне листинга наведите курсор на свечу с индексом 3, чтобы появилась информация о свойствах этой свечи, и сравните их с данными в окне сообщения. Запустите сценарий для других символов (финансовых инструментов), например, USDJPY, AUDUSD при различных настройках временного интервала, например, M30, H4, и сравните полученные данные.

Оператор цикла for

Циклы — еще один мощный инструмент MQL4. Они полезны для повторяющихся действий одного типа . Предположим, вам нужно найти среднее значение самых высоких цен для 5 свечей, то есть от 0 до 4. Вы можете сделать это, как показано в коде 1.

#property strict

void OnStart()
  {
//---
   double Av_High = 0.0;

   Av_High = ( High[0] + High[1] + High[2] + High[3] + High[4] ) / 5; 
                           
// --- отображаем результат 
   Alert ( "Средняя цена High свечей от 0 до 4 =" , Av_High); 
  }

В приведенном выше коде сначала была объявлена переменная Av_High типа double и ей было присвоено значение 0.0. Далее были суммированы значения High пяти свечей от [0] до [4], который потом были разделены на 5, и результат был присвоен Av_High. Последней инструкцией является отображение сообщения с помощью функции Alert ().

Здесь мы видим несколько повторяющихся математических действий,а именно суммирование пяти High. Давайте запишем этот код немного по-другому:

# Property strict

void OnStart()
{
//---
double Av_High = 0.0;

Av_High + = High[0]; // к Av_High мы добавляем значение цены High свечи с индексом 0
Av_High + = High[1];
Av_High + = High[2];
Av_High + = High[3];
Av_High + = High[4]; // Av_High равна сумме цен High свечей от 0 до 4
//---
Av_High / = 5; // Av_High равна одной пятой ранее полученной суммы

//--- просмотр результата
Alert ("Средняя цена High свечей от 0 до 4=", Av_High);
}

В этом коде мы использовали метод, описанный в разделе Работа с переменными в MQL4и здесь Av_High мы увеличиваем на другое значение High, используя обозначение + = . Запись Av_High / = 5 говорит о том , что сумма Av_High была разделена на 5 и разделить результат снова был присвоен переменной Av_High.

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

В переменную Av_High мы по очереди добавляем значения цен из массива High [] . Изменяется только индекс от [0] до [4] . Было бы намного проще использовать счетчик, который можно использовать для извлечения данных из этой таблицы. Посмотрите, как этот алгоритм может быть реализован с помощью цикла for :

#property strict 

void  OnStart () 
  { 
// --- 
   double Av_High = 0.0 ; 
// --- 'for' 
   for loop ( int i = 0 ; i < 5 ; i ++) 
     { 
      Av_High + = High [i]; 
     } 
// ---
    Av_High / = 5 ; 
// --- отображаем результат 

 Alert ( «Средняя цена свечей High от 0 до 4 =» , Av_High); 
  }

Цикл состоит из ключевого слова for. В круглых скобках (), т. е. в заголовке оператора, нужно ввести три аргумента, отделенных друг от друга точкой с запятой. Затем между  { }, т. е. в теле цикла, следует ввести повторяющиеся действия. Ниже приведена схема этого цикла.

for(condition_1 ; condition_2 ; condition_3)
  {
   // повторяющиеся действия
  }

• Condition_1: выполняется объявление и инициализация переменной, которая будет выступать в качестве счетчика. Ее имя может быть любым. Применяется только тип int. Здесь необходимо указать начальное значение индекса, с которого цикл начнет работать. Запись int i = 0 означает:

  • int — это тип переменной-счетчика,

  • i — это имя, а начальный индекс равен 0. 

• Condition_2: здесь проверяется условие прерывания цикла. Если значение счетчика не соответствует описанному здесь условию, цикл прерывается. Запись i < 5 означает – если значение счетчика  i соответствует этому условию ( 0 < 5 — true), тогда программа переходит к вычислениям, хранящимся в теле цикла, другими словами, к итерации (итерация — повторение той же операции).

• Condition_3: после выполнения вычислений в теле цикла, счетчик увеличивается на заданное значение. Запись i++ означает, что после завершения итерации счетчик и увеличится на 1.

В нашем примере выще в начале 4-й итерации, то есть, когда i = 3 , после завершения всех операций i будет увеличен на 1. Перед переходом к следующей итерации проверяется правильность второго условия и, если оно верно (в этом случае да, потому что 4 < 5 верно), тогда программа перейдет к выполнению последующих действий в теле цикла.

В конце 5-й итерации ( i = 4 ) i будет равен 5, и следующая итерация не будет реализована, поскольку второе условие больше не будет истинным ( 5 < 5 — false), это нарушит цикл for, и программа перейдет к действиям, написанным после цикла ,

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

i < = 5 // цикл работает до тех пор, пока i меньше или равно 5
i > 10 / / цикл работает в то время как i больше, чем 10
i >= 777 // цикл работает до тех пор, пока i больше или равно 777

Счетчик также можно изменить по-другому ( Condition_3 ):

i--      //  счетчик 'i' будет уменьшен на 1
i -= 2   //  счетчик 'i' будет уменьшен на 2
i += 25  // счетчик 'i' будет увеличен на 25

Чтобы закрепить материал, давайте теперь найдем среднее значение самых низких цен (Low) для 6 свечей с четными индексами, то есть свечей с индексами 0, 2, 4, 6, 8 и 10. Для небольшой сложности начнем считать с 10 до 0

#property strict 
void  OnStart () 
  { 
// --- 
   double Av_High = 0.0 ; 
   int     Start = 10 ; 
   int     End = 0 ; 

// --- 'for' 
   for loop ( int i = Start; i> = End; i - = 2 ) 
     { 
      Av_High + = Low [i]; 
     } 
// ---
    Av_High / = 6 ; 

// --- отображаем результат 
   Alert ( «Среднее значение цен Low четных свечей от 10 до 0 =» , Av_High); 
  }

Условный оператор if … else

Давайте разберемся, как использовать очень важный элемент MQL4, который является условием . В своей жизни вы часто мыслите условно, например: «Если в воскресенье солнечно, я пойду погулять. В противном случае я останусь дома. » В упрощенном виде на MQL4 это условие можно описать следующим образом:

#property strict 

void  OnStart () 
  { 
// --- 
   if ( / * Если в воскресенье солнечно * / ) 
     { 
        / * Я пойду гулять * /
      } 
   иначе
      { 
        / * Я останусь дома * /
      } 
  }

Это синтаксис условия в MQL4. Здесь вы можете увидеть условный оператор if (если) в сочетании с else (иначе). После слова if в круглых скобках () , т. е. в заголовке оператора, опишите условие, а затем опишите действия, которые будут выполнены в зависимости от выполнения этого условия. Если условие истинно (true), то желаемое действие должно быть описано в скобках {} ( я пойду на прогулку ). Если условие ложно (ложь), или в противном случае, после слова еще между фигурными скобками {} описывает альтернативное действие ( остаться дома ).

Теперь рассмотрим следующий пример:

// --- код 1
#property strict 
void  OnStart () 
  { 
// --- объявление переменных A и B и их инициализация 
   int A = 0 , B = 0 ; 
   if (A == 555 ) / * результат сравнения - false, в результате чего 
                     B не меняет свое значение на 100 
                     и действие переходит к оператору 'else' * /
      { 
        B = 100 ; 
     } 
   else
      { 
        B = 200 ;  // B принимает значение 200
      } 

// --- отображаем результат 
   Alert ("B =" , B); 
  }

В этом примере  в теле основной функции скрипта OnStart () объявлены первые две переменные A и B , присваивающие 0 каждому. Тогда при использовании оператора сравнения ==  А сравнивается с числом 555 . Это все равно что задавать программе вопрос «Является ли 0 равным 555?», Помня, что вместо переменной А программа видит 0 . Результат — ложь, потому что 0 не равно 555 . Согласно этому результату действие переходит к другому , где в теле этого оператора, то есть между {} , переменной B присваивается значение 200 . Наконец, функция Alert () отобразит «B = 200» на мониторе.

Вам не нужно использовать оператор else . Если в приведенном выше примере мы удалим else {…} , то переменная B останется неизменной и будет равна 0, как и во время инициализации.

#property strict 

void  OnStart () 
  { 
// --- объявление переменных A и B и их инициализация 
   int A = 0 , B = 0 ; 

   if (A == 555 ) / * результат сравнения - false и в результате 
                     B не меняет свое значение на 100 * /
      { 
        B = 100 ; 
     } 

// --- отображаем результат 
   Alert ( "B =" , B); // B = 0
   }

Также помните, что должны сравниваться только сопоставимые переменные и значения.

// --- объявление и инициализация переменных 
int     IntValue = 555 ; 
double DoubleValue = 1,3 ; 
string StringValue = "Какая-то информация" ; 
bool    BoolValue = true ; 

// --- 1) 
если (IntValue < 10 ) / * условие записано правильно, 
                     сравниваются два целых числа 555 и 10 * /
   { 
     // ...
   } 
// --- 2) 
if (DoubleValue> 2.5 ) / * правильно,
                         сравниваются два числа с плавающей точкой 1.3 и 2.5 * /
   { 
     // ...
   } 
// --- 3) 
если (IntValue> 2.5 )    / * правильно сохраненное условие, 
                         разрешено сравнивать две цифры 
                         разных типов, например, int и double * /
   { 
     // ...
   } 
// --- 4) 
если (StringValue == 1 )   / * полная ерунда, 
                         вы не можете сравнить текст с числом * /
   { 
     // ...
   } 
// --- 5) 
if (StringValue == "Word" ) // условие сохранено правильно
   { 
     // ...
   } 
// --- 6) 
если (StringValue> "Word" )   / * полная ерунда, 
                              невозможно сравнить, 
                              больше или меньше 
                              значение самого текста, чем значение другого текста, 
                              речь идет не о сравнении количества символов в этих текстах * /
   { 
     // ...
   } 
// --- 7) 
если (BoolValue == true ) / * правильно сохраненное условие, 
                         логическая переменная сравнивается
                         с логическим значением (true или false) * /
   { 
     // ...
   }

 Если после if между {} есть только одна инструкция (B = 100), то {} можно не писать. То же самое можно сделать и с else. В приведенном выше примере (код 1) после else между {} мы также видим только одну инструкцию (B = 200), поэтому скобки также могут быть опущены.

#property strict

int A = 0 , B = 0;
   
void OnStart()
  {
//---
   if(A == 555)  // Результат сравнения - false, операция переходит к оператору 'else'
      B = 100;
   else
      B = 200;   // zmienna B przyjmuje wartość 200
//---
   Print("B = " , B);  // переменная B принимает значение 200 
  }

Это тот же код, что и предыдущий, но немного более тонкий, потому что здесь нет {}. С другой стороны, если после операторов if или else необходимо написать два или более оператора, они должны быть заключены в фигурные скобки.

#property strict

int A = 0 , B = 0 , C = 0;

void OnStart()
  {
//---
   if(A == 555) // Результат сравнения - false, операция переходит к оператору 'else'
     {
      B = 100;
      C = 111;
     }
   else
     {
      B = 200;  // переменная B принимает значение 200
      C = 222;  // переменная C принимает значение 222
     }
//---
   Print("B = " , B , " a C = " , C); // B = 200 a C = 222
  }

В приведенном выше примере мы видим, что два оператора (B = 100 и C = 111) относятся к if и были бы реализованы, если бы условие было истинным, поскольку они находятся внутри скобок. Две инструкции (B = 200 и C = 222) относятся к else и также записываются между скобками.

Использование оператора else не требуется, если не предусмотрено альтернативное действие. Если в коде выше удалить else вместе с {…}, то начальные значения B и C не изменятся и все равно будут равны 0 (код 4).

#property strict

int A = 0 , B = 0 , C = 0;

void OnStart()
  {
//---
   if(A == 555) // Результат сравнения - false
     {
      B = 100;
      C = 111;
     }
                // из-за того, нет «else» B и C по-прежнему будет 0 
//---
   Print("B = " , B , " a C = " , C);  // B = 0 a C = 0
  }

 А что будет, если мы уберем {} и после if ? Сделайте это и запустите такой скрипт в MetaTrader 4.

#property строгого 

INT А = 0 , В = 0 , С = 0 ; 

void  OnStart () 
  { 
// --- 
   if (A == 555 ) // Результат сравнения - false
       B = 100 ;  // B не принимает значение 100
       C = 111 ;  // C принимает значение 111 
// --- 
   Print ( "B =" , B, "a C =" , C);  // B = 0 и C = 111
   }

В этом случае без {} только один оператор (B = 100) будет зависеть от оператора if. Второй оператор (C = 111) будет реализован независимо от if, поскольку в такой системе он не связан с этим оператором.

Вложение условий if … else в MQL4

В MQL4 есть возможность вложения операторов if и else, т. е. конкретное действие может зависеть от реализации нескольких условий. Подобные примеры многоуровневых условий можно изобразить следующим образом: «если в воскресенье будет солнце, то я пойду гулять. Если нет, то я посмотрю, будет ли по телевизору новый фильм, и если да, то посмотрю его, а если нет, то почитаю про MQL4″”. Сначала мы проверим, будет ли Солнце в воскресенье, и мы либо пойдем гулять, либо посмотрим, что будет по телевизору. Наши дальнейшие действия зависят от того, будет ли показан новый фильм. Как бы выглядел алгоритм принятия решений в человеческом мозге, если бы мы использовали язык MQL4?

#property strict

void OnStart()   // мы начинаем думать * :)
  {
//---
   if(/* Если в воскресенье будет солнце */)       // условие 1
     {
      /* пойду прогуляюсь */
     }
   else                                            // иначе
     {
      if(/* Если по телевизору будет новый фильм */) // вложенное условие 2
         {
          /* я буду смотреть новый фильм */
         }
      else                                         // иначе
         {
          /* почитаю про MQL4 */
         }
     }
//---
  }

В этом случае (код выше) наша прогулка будет зависеть только от одного условия: будет ли солнечное воскресенье. В свою очередь, о MQL4 мы прочитаем в случае, если не будет солнца и выяснится, что по телевизору не будет нового фильма. Давайте подготовим код сценария, как если бы мы уже знали, что воскресенье не будет солнечным, а на телевидении будет новый фильм (Код 2):

#property strict

void OnStart()
  {
   bool IsSunnySunday = false; // воскресенье не будет солнечным
   bool IsNewMovie    = true;  // будет новый фильм

//---
   if(IsSunnySunday == true)   /* результат сравнения-ложь,вот почему мы не пойдем на прогулку действие переходит к оператору 'else' */
     {
      Print("Пойду прогуляюсь.");
     }
   else                        //мы проходим здесь
     {
      if(IsNewMovie == true)   /*вложенное условие результат сравнения-правда, поэтому мы будем смотреть фильм, а не читать о MQL4*/
         {
          Print("Я буду смотреть новый фильм.");
         }
      else
         {
          Print("Я почитаю о MQL4.");
         }
     }
//---
  }

Функция Print, которая используется в этом коде описана ниже.

Что, если новый фильм окажется скучным? Лучше заняться чем-нибудь более приятным, например, почитать о MQL4. Мы можем добавить и такое условие и добавить, что мы будем делать в такой ситуации. Как я уже было написано выше, если после операторов if или else есть только одно действие, то скобки {} можно не писать. Кроме того, оператор else может быть опущен, если альтернативное действие не предусмотрено.

#property strict

void OnStart()
  {
   bool IsSunnySunday = false; // воскресенье не будет солнечным
   bool IsNewMovie    = true;  // будет новый фильм
   bool IsBoringMovie = true;  // фильм окажется неинтересным

//--- 
   if(IsSunnySunday == true)        // результат сравнения-ложь
      Print("Пойду прогуляюсь.");

   else                             // переходим сюда
     {
   //---
      if(IsNewMovie == true)        /* вложенное условие, результат сравнения-правда */
        {
          Print("Я буду смотреть новый фильм.");
          
          if(IsBoringMovie == true) // результат сравнения-правда
             Print("Фильм будет скучным, я лучше почитаю о MQL4.");
        }
      else
          Print("Я почитаю о MQL4.");
   //---
     }
  }

Теперь мы знаем, что если новый фильм окажется скучным, мы лучше читаем о MQL4. Однако, если фильм не разочаровывает наших ожиданий, мы ничего не меняем в нашей операции и продолжаем смотреть, потому что нет описания альтернативного действия, то есть больше ничего не связано с условием if ( IsBoringMovie == true ) . Теперь попробуйте инициализировать логическую переменную IsSunnySunday как true. Теперь при проверке первого условия скрипт немедленно отправит нас на прогулку, пропустив проверку следующих условий. В свою очередь, если мы заменим только логическую переменную IsNewMovie на false, нам не нужно проверять фильм, чтобы сразу начать читать о MQL4.

MQL4 позволяет вкладывать операторы if и else многими способами без ограничений. Существуют ситуации, когда вам необходимо описать очень сложные и обширные зависимости, например, некоторые действия могут зависеть от выполнения многих условий. Вы можете упростить ввод кода, используя логические символы && (I) и || (Или) о чем будет написано далее. Вы также можете писать свои собственные функции на mql4, используя такие сложные условия.

Функция Print() в MQL4

В этой главе мы познакомимся с очень полезной функцией Print (). В MQL4 он используется для отображения текста в журнале логов терминала MetaTrader 4.

#property strict 

void  OnStart () 
  { 
// --- 
   Print ("Это важное информационное сообщение"); 
  }

Сохраните этот код в тестовом скрипте , скомпилируйте и запустите его в MT4. 

На вкладке Эксперты мы увидим результат этого скрипта:

• Сначала терминал сообщит, что скрипт с именем Test успешно запущен в окне EURUSD.
• Затем идет запись инициализации скрипта.
• Результат сценария, то есть сообщение, сохраненное в сценарии.
• Деинициализация скрипта с указанием причины (0 означает отсутствие ошибки).
• Удаление скрипта из окна листинга.

Если по какой-либо причине вы не видите журнал терминала, то есть все нижнее окно, нажмите Ctrl + T или в строке меню Вид -> Терминал .

В приведенном выше примере заголовок функции Print () содержит 1 аргумент типа текста «Это важное информационное сообщение». Ниже рассмотрим некоторые другие примеры использования этой функции.

Вариант 2. В заголовке Print () есть 2 аргумента типа текста: первый — «День недели» ,  «Воскресенье». ,

#property strict

void OnStart()
  {
//---
   Print("День недели" , "Воскресенье.");
  }

Вариант 3. Сначала были объявлены две переменные Age_string и Height_string типа строка (string) и им присвоены текстовые значения. Затем в теле основной функции OnStart () Age_string был передан в заголовок Print () , а второй аргумент для Height_string был помещен после десятичной точки .

#property strict

string Age_string    = "25 лет ";
string Height_string = "мой рост 1,8.";

void OnStart()
  {
//---
   Print(Age_string , Height_string);
  }

Вариант 4. Сначала переменная Age_int целочисленного типа int и переменная Height_double типа с плавающей точкой double были объявлены и им были присвоены соответствующие значения. Затем в заголовок функции Print () было записано 5 аргументов: 1 — текстовый аргумент «Мне» , 2 — переменная Age_int , 3 — текст «лет и» , 4 — переменная Height_double и 5 — последний аргумент — текст «height m».

#property strict 

int     Age_int = 25 ; 
double Height_double = 1,95 ; 

void  OnStart () 
  { 
// --- 
   Print ( "Мне , 
         Age_int, 
         "лет и" , 
         Height_double, 
         "height m" ); 
  }

Операторы сравнения MQL4

До сих пор при обсуждении условного оператора if мы использовали оператор сравнения == . Напомнии, что один знак равенства = используется для присвоения значения переменной, а двойной знак равенства == используется для сравнения двух переменных. В этой части статьи мы узнаем о других операторах сравнения, используемых в MQL4.

оператор	описание
A == B	Истинно, если A — B
A! = B.	Истинно, если A не равно B
A <B	Истинно, если A меньше, чем B
A> B.	Истинно, если A больше, чем B
A <= B.	Истинно, если A меньше или равно B
A> = B.	Истинно, если A больше или равно B

Ниже несколько примеров использования этих операторов.

#property strict
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
///--- объявление и инициализация переменных 
   int    A_1 = 1,         A_2 = 1;
   double B_1 = -2.2,      B_2 = 5.5;
   string C_1 = "Pu ", C_2 = "Ok";
   bool   D_1 = true,      D_2 = false;

//--- 1)
   if(A_1 == A_2) // результат сравнения - true 
      Print("A_1 равно A_2");
   else
      Print("A_1 не равно A_2");

//--- 2)
   if(B_1 == B_2) 
      Print("B_1 равно B_2");
   else
      Print("B_1 не равно B_2");

//--- 3)
   if(C_1 == C_2) 
      Print("C_1 равно C_2");
   else
      Print("C_1 не равно C_2");

//--- 4)
   if(D_1 == D_2) 
      Print("D_1 равно D_2");
   else
      Print("D_1 не равно D_2");
 
  }
//+------------------------------------------------------------------+

Скопируйте этот код в скрипт, затем запустите его в терминале, и вы увидите сообщения на вкладке «Эксперты» . Затем скопируйте все коды ниже один за другим и проверьте их работу.

Примеры использования! = (… не равно …):

#property strict

void OnStart()
  {
   string C_1 = "Pu ", C_2 = "Ok";
   bool   D_1 = true,      D_2 = false;

//--- 1)
   if(C_1 != C_2) 
      Print("C_1 не равно C_2");
   else
      Print("C_1 равно C_2");

//--- 2)
   if(D_1 != D_2) 
      Print("D_1 не равно D_2");
   else
      Print("D_1 равно D_2");
  }

Примеры использования <(… меньше чем …): 

#property strict

void OnStart()
  {
   int    A_1 = 1,    A_2 = 1;
   double B_1 = -2.2, B_2 = 5.5;

//--- 1)
   if(A_1 < A_2) 
      Print("A_1 меньше, чем A_2");
   else
      Print("A_1 не меньше, чем A_2");

//--- 2)
   if(B_1 < B_2) 
      Print("B_1 меньше, чем B_2");
   else
      Print("B_1 не меньше B_2");
  }

Примеры применения > (… это больше, чем ): 

#property strict

void OnStart()
  {
   int    A_1 = 1,    A_2 = 1;
   double B_1 = -2.2, B_2 = 5.5;

//--- 1)
   if(A_1 > A_2) // 

      Print("A_1 больше, чем A_2");
   else
      Print("A_1 не больше, чем A_2");

//--- 2)
   if(B_1 > B_2) // wynik porównania - fałsz

      Print("B_1 больше, чем B_2");
   else
      Print("B_1 не больше, чем B_2");
  }

Логические операции && и || в MQL4

С целью демонстрации работы операторов && и || предлагаем проанализировать следующий пример: «если сегодня воскресенье и (&&) есть солнце, то я иду на прогулку. Иначе я останусь дома». Давайте подготовим такой сценарий.

#property strict

void OnStart()
  {
   bool IsTodaySunday = true;  //сегодня воскресенье
   bool IsTodaySunny  = true;  // сегодня солнце
   
//---
   if(IsTodaySunday == true && IsTodaySunny == true)
      Print("Я иду на прогулку, потому что это воскресенье, и есть солнце.");
   else
      Print("Я остаюсь дома.");
//---
  }

В заголовке оператора if, т. е. между скобками (), мы видим два условия, разделенных символом &&. В первом выражении мы проверяем, что переменная IsTodaySunday равна true: да, это правда, потому что во время инициализации ей было присвоено именно такое значение. Во втором выражении мы проверяем, что IsTodaySunny тоже равен true: да-правда. Поскольку эти два условия одновременно реальны, мы можем пойти на прогулку. Если бы оказалось, что хотя бы один из них не был истиной, например. во время инициализации одна из переменных будет иметь значение false, то в соответствии с сохраненным кодом мы не можем пойти на прогулку.

Оператор логического произведения && используется, когда все сохраненные условия должны быть истинными.

В MQL4 таким образом в одном if можно одновременно проверять несколько условий.

#property strict

void OnStart()
  {
   bool IsTodaySunday = true;   // сегодня воскресенье
   bool IsTodaySunny  = true;   // сегодня солнце
   bool IsNewMovie    = false;  // нет нового фильма

//---
   if(IsTodaySunday == true &&  // правда-сегодня воскресенье
      IsTodaySunny  == true &&  // правда-сегодня солнце
      IsNewMovie    == false)   // правда-нового фильма нет
      Print("Я иду на прогулку, потому что это воскресенье, и есть солнце, и нет нового фильма.");
   else
      Print("Я остаюсь дома.");
//---
  }

В приведенном выше примере мы дополнительно проверяем, идет ли новый фильм по телевизору. Во время инициализации мы присвоили IsNewMovie значение false, т. е. нет нового видео. В заголовке if в третьем выражении мы проверяем это условие и видим, что оно истинно (false равно false что верно), и поскольку все 3 условия истинны, мы идем на прогулку. Попробуйте какую-нибудь переменную инициализировать по-другому, и вы увидите, что скрипт будет приказывать вам оставаться дома.

Оператор логической суммы ||  позволяет реализовать желаемое действие, если хотя бы одно из условий истинно.

Проверьте, как будет работать следующий скрипт.

#property strict

void OnStart()
  {
   bool IsTodaySunday = true;  // сегодня воскресенье
   bool IsTodaySunny  = false; // сегодня нет солнца

//---
   if(IsTodaySunday == true || IsTodaySunny == true)
      Print("Я иду на прогулку, потому что либо воскресенье, либо солнце.");
   else
      Print("Я остаюсь дома.");
//---
  }

Такой сценарий отправит нас на прогулку, потому что для выполнения хотя бы одного из условий достаточно. Здесь первое условие реально, а второе нет. Если бы все было наоборот, то есть сегодня не было бы воскресенье, но было бы солнце, нам также пришлось бы выйти на улицу, чтобы проветрить. Только если ни одно из условий не было выполнено, действие перешло бы к оператору else, и сценарий попросил бы нас остаться дома. Аналогично && , с оператором || вы можете проверить много условий одновременно.

 Группировка условий

Давайте рассмотрим, как сгруппировать несколько условий внутри оператора if . Проанализируйте код ниже.

#property strict 

void  OnStart () 
  { 
   int A = 0 , B = 1 , C = 2 , D = 3 ; 

// --- 
  if (A == 0 && B <- 9 )       /* group # 1 (A == 0 - true, B <-9 - false) 
                                общий результат сравнения - ложное 
                                действие переходит к оператору 'else' */ 
      Print ("Желаемое действие № 1"); 
   else
      { 
      if (C!=0 && D>-9)   /*группа № 2 (C! = 0 - true, D> -9 - true) 
                                общий результат сравнения - true */ 
         Print ( "Желаемое действие № 1" ); 
      else 
         Print ( "Альтернативное действие № 2" ); 
     } 
// ---
   }

Мы видим, что желаемое действие № 1 зависит от того, верно ли сравнение переменных A и B вместе. Если бы это было так, сценарий отображал бы сообщение, сохраненное в первой функции Print (), и сценарий заканчивался бы там. У нас это не так, поэтому скрипт перейдет к другому условию и выполнит действия, сохраненные в {} . Там, в if , мы видим вторую группу условий для переменных C и D , где оба выражения верны, поэтому будет отображаться сообщение «Желаемое действие № 1». , Допустим, сравнения A и B являются группой № 1, а сравнения C и D — группой № 2.

В первой группе сравнение A с числом 0 дает результат — true, но сравнение B с числом — 9 дает результат — false. Оператор логического произведения && (||) записан в этой группе , поэтому конечный результат для этой группы — ложь. Во второй группе сравнение как C, так и D дает реальные результаты, и, поскольку && также записывается здесь, результат всей группы является истинным. Если оказалось, что для обеих групп результаты сравнения были ложными, тогда сценарий запустил бы альтернативное действие № 2. Поэтому для выполнения требуемого действия № 1 первой или второй группе достаточно дать результат — true.

Теперь посмотрим, как вы можете сохранить тот же код короче.

#property strict 
void  OnStart () 
  { 
   int A = 0 , B = 1 , C = 2 , D = 3 ; 
// --- 
   if ((A == 0 && B <- 9 ) || (C! = 0 && D> - 9 )) 
      Print ( "Желаемое действие № 1" ); 
   else 
      Print ( "Альтернативное действие № 2" ); 
// ---
   }

Теперь в if с помощью скобок мы создали группу № 1 (A == 0 && B <- 9 ) и группу № 2 (C! = 0 && D> — 9 ) . В этом случае оператор if сначала проверит результаты для отдельных переменных, затем оценит общий результат для каждой из этих групп, а затем сравнит результаты самих групп. Чтобы было понятнее, посмотрите на рисунок ниже:

Форекс — торговые стратегии, советники, индикаторы, видео обучение торговле

---