MQL5 lernen, vom Anfänger zum Profi (Teil I): Beginn der Programmierung

Einführung

Ich erhalte manchmal private Nachrichten von Personen, die lernen möchten, wie sie ihre eigenen Expert Advisors oder Indikatoren erstellen können. Obwohl es auf dieser Website und im Internet im Allgemeinen viel Material gibt, darunter auch sehr gute Quellen mit Beispielen, brauchen Anfänger immer noch Hilfe. Einige Nutzer wünschen sich eine einheitlichere Darstellung, andere eine klarere oder eine andere Form. Manchmal fragen Nutzer: „Fügen Sie Kommentare zum Code eines funktionierenden Expert Advisors hinzu, ich werde alles verstehen und selbst einen solchen erstellen!“ Aber nachdem sie hundert Zeilen Code gesehen haben, bekommen sie Angst, sind verwirrt und geben die Idee auf. Stattdessen sagen sie: „Erstellen Sie lieber einen Expert Advisor für mich.“

Trotzdem gibt es Leute, die immer noch „alles verstehen“ wollen. In diesem Fall kann ein schrittweiser Leitfaden, der die Dinge von einfach bis komplex erklärt, sehr nützlich sein. Nun, eine solche Schritt-für-Schritt-Anleitung für die MQL5-Sprache können Nutzer nicht finden.

Die Handbücher, die ich gesehen habe, gehen davon aus, dass eine Person bereits etwas Erfahrung mit der Programmierung hat und versteht, wie sie funktioniert. Daher bieten die Leitfäden Erklärungen zu Nuancen.

Ich beginne diese Artikelserie speziell für Anfänger, für diejenigen, die zum ersten Mal mit dem Programmieren in Berührung kommen und bereit sind, es zu lernen. Diese Artikel sind für Händler gedacht, die nicht mehr von Programmierern abhängig sein wollen und verstehen möchten, wie alles funktioniert. Die Artikel bieten konsistente und detaillierte Informationen mit Bildern und Beispielen, die den Leser auf das Niveau der „MQL5-Sprachkenntnisse“ führen.

Diese Sprache kann nicht nur zur Automatisierung des Handels, sondern auch zur Lösung anderer damit verbundener Aufgaben verwendet werden. Sie können damit zum Beispiel Indikatoren, Optimierungsergebnisse und beliebige nutzerdefinierte Formen darstellen, Dateien wie Listen von Tick-Kursen oder Screenshots der aktuellen Handelssituation erstellen, Nachrichten an Telegram und andere Messaging-Bots senden, mit Datenbanken arbeiten und vieles mehr.

Ich möchte nach und nach die maximalen Möglichkeiten der Sprache aufzeigen: die Verwendung von „virtuellen Symbolen“, Operationen mit mathematischen Bibliotheken und vieles mehr. Dieses Mal beginnen wir mit den Grundlagen.

Grundlegende Fachbegriffe

Fast alle modernen Computer sind auf der Grundlage der Von-Neumann-Architektur aufgebaut. Um Literatur erfolgreich lesen zu können, müssen Sie die Begriffe verstehen, die Programmierer verwenden.

• Central Processing Unit (oder CPU, die zentrale Recheneinheit). Dieses Modul ist für alle Berechnungen und die Logik zuständig.
• Random Access Memory (RAM, Speicher). Im RAM werden Daten und Programme gespeichert. Wenn Sie den Computer ausschalten oder ein Programm schließen, werden die Daten im RAM gelöscht.
  
• Externe Laufwerke (Flash-Laufwerke, HDD, SSD, usw.). Die CPU kann Daten in Form von Dateien auf sie schreiben.
  
• Mit Dateien sind Informationen gemeint, die auf externen Medien (nicht im RAM) gespeichert sind.
• Ausführungsfaden. Während des Betriebs nimmt die CPU Daten aus dem RAM, „versteht“, ob es sich um einen Befehl oder um Daten handelt, führt den Befehl aus und schreibt die Ergebnisse entweder zurück in den RAM oder auf ein vom laufenden Programm angegebenes externes Laufwerk. Dann wird das nächste Speicherfragment erneut gelesen, und so weiter, bis das Programm endet. Dieser gesamte Prozess wird als „Ausführungsfaden“, engl. execution thread, bezeichnet.
  

Es gibt verschiedene Metriken zur Messung von Informationen.

• Das Bit ist die grundlegendste Einheit der Information. Eigentlich ist es ein „Schalter“, der den Zustand eines bestimmten, winzigen Teils des Speichers bestimmt. Ein Bit enthält entweder „0“ (deaktiviert) oder „1“ (aktiviert).
• Byte kann als eine „Silbe“ erklärt werden. Es ist das kleinste „Paket“ von Informationen, das 8 Bit entspricht. Als Computer noch groß waren und ganze Stockwerke beanspruchten, der Arbeitsspeicher winzig war und Dateien auf Lochkarten gespeichert wurden, waren 8 Bit der beste technische Kompromiss zwischen Geschwindigkeit (bis zu 8 Löcher können gleichzeitig gelesen werden!) und Größe des Datenträgers.
  

Für einen Programmierer ist es manchmal wichtig zu wissen, wie viel Speicherplatz ein Programm beanspruchen wird. In der modernen Welt nehmen Programme (und vor allem ihre Daten) in der Regel viel Platz ein, weshalb dem Wort „Byte“ metrische Präfixe hinzugefügt werden.

Bei der Messung physikalischer und nicht informationeller Größen meldet jede solche Vorsilbe eine 1000-fache Vergrößerung der vorherigen Größe. Ein Kilometer entspricht zum Beispiel 1000 Metern, und ein Megavolt entspricht 1000 Kilovolt oder 1.000.000 Volt.

Wenn es sich jedoch um Computerdaten handelt, ist jedes nächste metrische Präfix um das 1024-fache größer als das vorherige.

So entspricht beispielsweise ein Kilobyte (KB) 1024 Bytes, ein Megabyte (MB) enthält 1024 Kilobytes, und so weiter. Weitere Präfixe sind: Giga, Tera, Peta, usw.

Wir werden uns in späteren Artikeln mit der Speicherverwaltung, Befehlen an den Prozessor, dem Schreiben von Dateien mit MQL5 und anderen Routineaufgaben beschäftigen.

Die fettgedruckten Begriffe werden in den Artikeln häufig vorkommen, deshalb beschreibe ich sie hier gleich zu Beginn. Andere Begriffe werden an der Stelle eingeführt, an der sie zum ersten Mal auftauchen. Ich kann auf Begriffe nicht verzichten, aber ich werde versuchen, ein Minimum davon zu verwenden.

Erforderliche Software für die Programmierung in MQL5

Um einen Computer für Menschen nützlich zu machen, muss man für jede Art von Aktivität ein Programm schreiben: Handel, Bilder ansehen, Musik hören und andere.

Es ist durchaus möglich, Programme direkt in Prozessorbefehlen zu schreiben. Aber das ist sehr unproduktiv.

Deshalb gibt es in der modernen Welt viele Assistenzprogramme, die dabei helfen, Texte in menschenähnlichen Sprachen in für Prozessoren verständliche Befehle umzuwandeln.

Hier ist eine Mindestliste solcher Programme, die für Programmierer erforderlich sind:

1. Text-Editor. In dieser Software schreiben Sie Ihren Code. Jeder Editor, den Sie mögen, ist geeignet. Es sollten jedoch keine zusätzlichen Zeichen zu dem von Ihnen eingegebenen Text hinzugefügt werden. Es ist sehr praktisch, wenn ein Editor die Syntax der Sprache, die Sie benötigen (in diesem Fall MQL5), hervorheben kann.

   Wenn Sie MetaTrader installieren, wird automatisch ein sehr leistungsfähiger Editor namens MetaEditor auf dem System installiert. Es kann alles, was Sie brauchen.

   Wenn es Ihnen jedoch aus irgendeinem Grund nicht gefällt, können Sie etwas anderes wählen. Einer der beliebtesten Editoren, die von Programmierern verwendet werden, ist beispielsweise Visual Studio Code (VSCode). Mit Hilfe von Plugins können Sie es für die Arbeit mit MQL5 konfigurieren.

2. Compiler. Der Compiler wandelt den von einem Programmierer in einem Editor geschriebenen Text in Maschinencode um. Erst nach der Umwandlung kann die CPU diesen Code ausführen.

   Für die Sprache MQL5 ist der Compiler in MetaEditor integriert. Bei anderen Sprachen, z. B. C++, kann der Compiler ein separates Programm sein.

   Einige Sprachen, wie z. B. Python, haben keinen expliziten Compiler. Sie führen sozusagen den Text aus Ihrer Datei direkt aus.

   Das Programm, das Dateien für solche Sprachen liest, wird als „Interpreter“ bezeichnet, und die Sprachen selbst werden dementsprechend als „interpretiert“ bezeichnet. Es ist jedoch wichtig zu verstehen, dass auch Interpreter letztendlich Maschinencode ausführen. Der Unterschied ist, dass die Umwandlung von Text in Code nicht so offensichtlich ist.
   

3. Debugger. Mit diesem Tool können Sie Fehler in Ihrem Programm finden und beheben. Sie ermöglicht die schrittweise Ausführung von Code, der darauf abzielt, die Daten zu überprüfen, mit denen Ihr Programm zu einem bestimmten Zeitpunkt bei jedem Schritt arbeitet.

   MetaEditor bietet einen eingebauten Debugger.

4. Versionskontrollsystem (VCS). Ein solches System hilft Ihnen, die Änderungen an Ihrem Code zu verfolgen.

   Wenn Sie eine Menge Code geschrieben haben und plötzlich feststellen, dass die Version von vorgestern viel besser funktioniert oder Sie generell einen anderen Weg einschlagen müssen, können Sie mit einem VCS den vorherigen Zustand der Datei (und sogar des gesamten Projekts) mit nur wenigen Klicks oder Textbefehlen über die Tastatur „zurücksetzen“.

   Vor allem aber speichern VCS die Daten oft auf einem entfernten Server und nicht auf Ihrem lokalen Computer, sodass Sie im Falle eines Ausfalls (z. B. eines Festplattendefekts) Ihre Arbeit schnell wiederherstellen können.

   Diese beiden wichtigen Faktoren haben dazu geführt, dass verschiedene Versionskontrollsysteme für die Arbeit in Unternehmen praktisch obligatorisch sind, da sie auch die Zusammenarbeit mit anderen Entwicklern ermöglichen. Die Gewohnheit, diese Hilfsmittel zu nutzen, ist auch bei der selbstständigen Arbeit sehr hilfreich, da verschiedene Dinge passieren können.

   Es gibt Lösungen von Drittanbietern wie Git. Ein solches Werkzeug ist jedoch auch in MetaEditor integriert. Die Fähigkeiten des eingebauten VCS sind für Anfänger mehr als ausreichend.

Dies ist der Werkzeugkasten, ohne den moderne Programmierung nicht existieren kann. Programmierer können Versionierungswerkzeuge separat verwenden. In der modernen Welt kommt dies jedoch relativ selten vor. In der Regel entscheiden sich die Nutzer für Software wie MetaEditor, die alle diese Funktionen (und noch mehr) bietet.

Die Softwarelösungen, die alle oben genannten Komponenten (Texteditor, Compiler, Debugger und andere) enthalten, werden als integrierte Entwicklungsumgebung (IDE) bezeichnet.

Haupttypen von MQL5-Programmen

Die Programmanwendungen, die in MetaTrader 5 ausgeführt werden können, lassen sich in vier Typen unterteilen:

1. Skripte. Sie können Informationen anzeigen, Handel treiben oder grafische Objekte darstellen. Um das Skript auszuführen, müssen Sie es jedes Mal neu starten, wenn Sie es benötigen.
   
2. Indikatoren. Sie sind so konzipiert, dass sie bei jedem Tick Informationen für eine Handelsstrategie anzeigen. Sie handeln nicht auf eigene Faust.
3. Expert Advisors(EAs). Diese Programme sind für den Handel konzipiert. Wie Indikatoren werden sie bei jedem Tick ausgeführt, verfügen aber nicht über alle Werkzeuge zum Zeichnen von Pfeilen oder nützlichen Linien.
4. Dienste. Im Gegensatz zu allen anderen Arten von Programmen benötigen die Dienste kein spezielles Chart, um darauf zu laufen. Sie werden einmal beim Starten des Terminals ausgeführt. Sie können erzwingen, dass sie im Speicher bleiben, bis das Terminal geschlossen wird (und sogar noch einige Zeit danach), aber sie können nicht auf Terminalereignisse reagieren, wie z. B. das Eintreffen eines neuen Ticks oder eines Mausklicks.

Vergleich der in MQL5 verfügbaren Programmtypen

Alles, was mit der Verwendung von Programmen in MQL5 zusammenhängt, lässt sich in einer einfachen Tabelle zusammenfassen:

Tabelle 1. Vergleich der Fähigkeiten der wichtigsten MQL5-Programmtypen.

Fähigkeiten des Programms	Skripte	Indikatoren	Expert Advisors	Dienste
Verknüpfung mit einem bestimmten Chart	ja	ja	ja	nein
Kann handeln	ja	nein	ja	ja
Aus dem Speicher entladen, wenn sich der Zeitrahmen ändert	ja	ja	ja	nein
Wird bei jedem Tick ausgeführt	nein	ja	ja	nein
Wird einmalig beim Öffnen des Terminals ausgeführt	nein	nein	nein	ja
Läuft auf einem offenen Chart	nein	ja	ja	nein
Kann verschiedene Terminal- oder Chartereignisse verarbeiten	nein	ja	ja	nein
Kann den Timer starten und stoppen	nein	ja	ja	nein
Automatischer Aufruf von Initialisierungs- und Deinitialisierungsfunktionen	nein	ja	ja	nein
Nur eine Instanz des Programms kann auf dem Chart ausgeführt werden	ja	nein	ja	—

Funktionen

Jedes Programm sollte etwas tun, d.h. einige Funktionen ausführen.

Jede Funktion ist eine Menge von Programmaktionen, die zu einem (oft elementaren) Ergebnis führen. Sie können zum Beispiel eine Textzeile drucken, einen Buchstaben zeichnen oder ein Handelsgeschäft eröffnen.

Einige Programmiersprachen verlangen keine explizite Deklaration von Funktionen. Eine solche Deklaration ist in MQL5 obligatorisch: Jedes Programm muss mindestens eine deklarierte Startfunktion haben, sonst kommt es zu einer Fehlermeldung. Für jede Art von Programm werden die Ausgangsfunktionen unterschiedlich aufgerufen. Ein Programm muss aber auf jeden Fall Funktionen haben, sonst wird es sinnlos, weil es gar nichts tut.

In fast jeder Programmiersprache können nutzerdefinierte Funktionen erstellt werden, um sich wiederholende Codeteile zu trennen und diese dann in einer Zeile wiederzuverwenden, anstatt sie immer wieder neu zu schreiben. Darüber hinaus verfügen alle Sprachen über eine Reihe von vorgegebenen Funktionen. Es sind diese vordefinierten Funktionen, die eine Programmiersprache von allen anderen unterscheiden.

Wenn von einer Sprache die Rede ist, versuchen die Autoren oft zu beschreiben, welche Funktionen in ihr vordefiniert sind und wie man sie am besten einsetzt, um das gewünschte Ergebnis zu erzielen.

MQL5 ist da keine Ausnahme. Es enthält eine Reihe von eingebauten Funktionen und ermöglicht die Erstellung von nutzerdefinierten Funktionen. Die eingebauten Funktionen der Sprache können mit Hilfe der Kontexthilfe bequem studiert werden. Um die Hilfe aufzurufen, öffnen Sie einen beliebigen Code (auch den von jemand anderem geschriebenen) in MetaEditor, klicken Sie auf ein markiertes Wort und drücken Sie die Taste <F1>.

Bestimmte Programmtypen können bestimmte integrierte Funktionen nicht aufrufen. Einige müssen, wie bereits erwähnt, genau wie in der Hilfe beschrieben implementiert werden. Außerdem erfordern verschiedene Programmtypen unterschiedliche Funktionen.

Aber ansonsten sind unserer Kreativität fast keine Grenzen gesetzt. Wir können beliebige Hilfsfunktionen erstellen, sie in beliebiger Weise organisieren und sogar Funktionen verwenden, die in anderen Sprachen wie C++ oder Python beschrieben sind. Auf all diese Funktionen werden wir in künftigen Artikeln eingehen.

Beginnen wir nun mit dem Einfachsten, was die MQL5-Sprache zu bieten hat: Wir erstellen ein Skript, das einmal ausgeführt wird, wenn es mit der Maus auf das Chart gezogen wird. In diesem Skript wird mit Hilfe einer Standardfunktion der MQL5-Sprache eine normale Textnachricht für den Nutzer in einem Standardfenster am unteren Rand des Terminals angezeigt.

Starten und Einrichten der IDE

Schließlich kommen wir zur Praxis! Im Moment werden wir die gesamte Arbeit in MetaEditor erledigen. Es kann entweder über eine Verknüpfung (auf dem Desktop oder im Startmenü) oder direkt vom MetaTrader-Terminal aus mit einer der in der folgenden Abbildung dargestellten Methoden gestartet werden (Abbildung 1).

.

Abbildung 1. Drei Möglichkeiten, den MetaEditor zu öffnen: 1 - Schaltfläche in der Symbolleiste, 2 - Menü, 3 - Hotkey (F4)

Sobald das Editorfenster geöffnet ist, empfehle ich Ihnen, sofort Ihren Nutzernamen und Ihr Passwort von der mql5.com-Website einzugeben (oder, falls Sie noch nicht registriert sind, dies zu tun). Wenn Sie sich anmelden, können Sie Ihre Projekte mit der in MetaEditor integrierten Versionskontrolle direkt auf dem Server speichern. Niemand kann Ihre gespeicherten Dateien sehen, es sei denn, Sie erlauben den Zugriff. Das Speichern Ihrer Arbeit in der MetaQuotes-Cloud ist also so sicher, wie das Speichern von Informationen im Internet nur sein kann, und das ist eine gute Praxis (Speichern Ihrer Arbeit nicht nur auf Ihrem Computer).

Abbildung 2. MQL5.com Autorisierungsdialog

Um den Autorisierungsdialog zu öffnen, wählen Sie im Hauptmenü des Editorfensters Werkzeuge -> Einstellungen und navigieren Sie zur Registerkarte Gemeinschaft. Diese Einstellung muss nur einmal vorgenommen werden. Diese Daten werden im Editor gespeichert, und Sie können das Versionskontrollsystem und andere nützliche MQL5-Dienste reibungslos nutzen.

Erstes Skript

Nun... Klicken Sie einfach mit der rechten Maustaste auf den Ordner im linken Dashboard, in dem Sie das Skript erstellen möchten, und wählen Sie „Neue Datei“. Optional können Sie auch <Ctrl>+<N>... Wählen Sie in dem daraufhin angezeigten Fenster die Option Skript. Geben Sie im nächsten Fenster den Dateinamen ein.

Abbildung 3. Methoden zur Erstellung einer neuen Datei.

Abbildung 4. Dialogfeld des Dateierstellungsassistenten - wählen Sie den Typ des zu erstellenden Programms aus.

Abbildung 5. Dialogfeld des Dateierstellungsassistenten - geben Sie den Namen des zu erstellenden Programms ein.

Als Ergebnis erhalten Sie ein neues Fenster mit folgendem Inhalt:

//+------------------------------------------------------------------+
//|                                                   HelloWorld.mq5 |
//|                                       Oleg Fedorov (aka certain) |
//|                                   mailto:[e-mail] |
//+------------------------------------------------------------------+
#property copyright "Oleg Fedorov (aka certain)"
#property link      "mailto:[e-mail]"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   
  }
//+------------------------------------------------------------------+

Beispiel 1. Vom Assistenten generierte Skriptvorlage.

Es scheint nicht kompliziert zu sein, nur 17 Zeilen Code.

Sehen wir uns an, was genau hier geschrieben steht.

• Zunächst gibt es mehrere Zeilen am Anfang, die mit doppelten Schrägstrichen ( // ) beginnen. Ähnliche Linien erscheinen auch in der Mitte des Programms.

Dies sind Kommentare. Sie sind für Menschen geschrieben, sodass der Compiler sie bei der Generierung von Bytecode ignorieren wird. Kommentare, die mit einem doppelten Schrägstrich beginnen, werden als einzeilige Kommentare bezeichnet. Sie befinden sich am Ende der Zeile. Die Regel ist sehr einfach: Alles, was vor dem doppelten Schrägstrich kommt, wird vom Compiler als Code betrachtet, und alles, was nach dem doppelten Schrägstrich folgt, ist Text für einen Menschen.

In dieser vom Assistenten erstellten Vorlage war der „davor“-Code in diesem Zusammenhang nicht erforderlich.

In MetaEditor können Sie schnell ein paar Zeilen auskommentieren: Markieren Sie sie und drücken Sie die Tastenkombination " <Ctrl>+< ' > (Strg + Apostroph). Um solche Zeilen zu entfernen, markieren Sie sie erneut und drücken Sie die Tastenkombination <Ctrl>+< ; >.

Es gibt auch mehrzeilige Kommentare. Sie beginnen mit den Zeichen /* und enden in umgekehrter Reihenfolge */. Mehrzeilige Kommentare können an jeder Stelle des Codes eingefügt werden, an der Leerzeichen zulässig sind. Beim Kompilieren „entfernt“ der Compiler auch solche Sequenzen zunächst und versucht erst dann herauszufinden, was der Autor implementieren wollte.

In der Praxis werden Kommentare nur selten mitten in den Code eingefügt. Meistens ist es einfach unbequem. Sie sind jedoch sehr nützlich, wenn es darum geht, große Blöcke mit unnötigem Code zu kommentieren oder Funktionsköpfe zu beschreiben.

So könnte die Kopfzeile dieser Datei aussehen, wenn wir einen mehrzeiligen Kommentar verwenden würden (wenn ich den Code selbst geschrieben hätte, anstatt ihn vom MetaEditor-Assistenten generieren zu lassen):

/*
                                                   HelloWorld.mq5 
                                       Oleg Fedorov (aka certain) 
                                   mailto:[e-mail] 
*/

Beispiel 2. Mehrzeilige Kommentare.

Oder so:

/*******************************************************************
 *                                                  HelloWorld.mq5 *
 *                                      Oleg Fedorov (aka certain) *
 *                                  mailto:[e-mail] *
 *******************************************************************/

Beispiel 3. Verzierte mehrzeilige Kommentare.

Im Allgemeinen kann zwischen den Zeichen /* und */ oder nach // ein beliebiger Text in einer beliebigen Sprache stehen. Ich sage das in jeder Sprache, weil moderne Editoren die Unicode-Kodierung vollständig unterstützen. Es wird jedoch empfohlen, die englische Sprache zu verwenden, da dies Zeit beim Umschalten der Sprache spart (was bei großen Projekten sehr wichtig ist).

• Der zweite interessante Block besteht aus den Zeilen, die mit # beginnen. In dieser Datei sind die ersten Wörter jeder Zeile dieses Blocks #property.

Im Allgemeinen ist jedes Wort, das mit einem Rautenzeichen beginnt, eine Präprozessoranweisung. Der Compiler muss nicht nur alle Kommentare entfernen, bevor er den Text in Maschinencode umwandelt. Sie muss auch andere Vorbereitungen treffen. In der Regel gibt es eine Menge Vorarbeit, denn bei großen Projekten ist es notwendig, die resultierende Lösung aus mehreren Dateien zusammenzusetzen, einige Daten zu definieren (z. B. Konstanten wie die Zahl Pi oder etwas Ähnliches, obwohl es auch komplexere Fälle gibt), und so weiter. Wir werden uns mit all diesen Richtlinien erst viel später befassen.

Um den resultierenden Code zu verstehen, müssen wir zunächst wissen, dass die #property-Direktive eine Eigenschaft des resultierenden Programms beschreibt. Meistens wirken sich diese Eigenschaften auf das Anfangsfenster aus, das sofort erscheint, nachdem der Nutzer unser Programm durch Ziehen des Symbols auf das Chart gestartet hat.

Um dies zu veranschaulichen, fügen wir dem Code eine weitere Zeile hinzu:

#property copyright "Oleg Fedorov (aka certain)"
#property link      "mailto:[e-mail]"
#property version   "1.00"
#property script_show_inputs

Beispiel 4. Hinzufügen der Eigenschaft script_show_inputs.

Diese Zeile ermöglicht es Ihnen, das Eingabefenster anzuzeigen und erst dann mit der Ausführung des Hauptcodes zu beginnen. Wenn diese Zeile nicht vorhanden ist, wird das Skript sofort ausgeführt, ohne dass eine Meldung angezeigt wird. Wenn es keine Eingaben gibt, verwendet das Skript Standardwerte.

Nachdem wir also die erforderliche Zeile an die gewünschte Stelle in der Datei geschrieben haben (unmittelbar nach der Eigenschaft „version“), führen wir die erste Kompilierung unseres Programms durch.

Wählen Sie eine der in der Abbildung gezeigten Methoden aus (drücken Sie zum Beispiel die Taste <F7>).

Abbildung 6. Mehrere Möglichkeiten, ein Programm zu kompilieren.

Warten Sie ein paar Sekunden lang. Das war's - das Programm wurde kompiliert (Abbildung 7).

Abbildung 7. Ergebnisse der Kompilierung. In diesem Fall war die Kompilierung erfolgreich (0 Fehler). Es dauerte 527 Millisekunden und erstellte den Bytecode für einen 64-Bit-Prozessor.

Abbildung 9 zeigt, dass die Kompilierung erfolgreich war. Wenn die Textdatei Fehler enthielt, wurden im selben Fenster entsprechende Meldungen angezeigt.

Nach der Kompilierung wird das Skript-Symbol automatisch in der Liste der Skripte in Ihrem Handelsterminal angezeigt. Um zum Terminal zu wechseln, können Sie z.B. im Editor die Taste <F4> drücken. Das spart etwas Zeit.

Ziehen Sie das Skript mit der Maus auf das Chart und sehen Sie das Eigenschaftsfenster.

Abbildung 8. Skript-Eingabefenster.
(1) Das Symbol des laufenden Skripts wird in der oberen rechten Ecke des Hauptfensters angezeigt.
(2) Die Registerkarte Common zeigt die Verwendung von Eigenschaften, die mit #property-Direktiven beschrieben werden.
(3) MetaEditor hat zusätzliche Parameter zu der in der Eigenschaft „link“ angegebenen Adresse hinzugefügt.
Wahrscheinlich zeigt dies, woher die Besucher kommen, wenn wir einen Website-Link verwenden.

Schließen wir das Fenster, kehren wir zum Editor zurück und versuchen wir, das Skript anzuweisen, etwas Nützliches zu tun, z. B. eine Meldung für den Nutzer anzuzeigen.

Dazu kommentieren Sie die Zeile aus, die das Parameterfenster anzeigt (wir haben noch nichts zu ändern), und fügen eine weitere Zeile hinzu, die eine Meldung schreibt:

//+------------------------------------------------------------------+
//|                                                   HelloWorld.mq5 |
//|                                       Oleg Fedorov (aka certain) |
//|                                   mailto:[e-mail] |
//+------------------------------------------------------------------+
#property copyright "Oleg Fedorov (aka certain)"
#property link      "mailto:[e-mail]"
#property version   "1.00"
//#property script_show_inputs

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   Print("Hello, MQL5 world!");
  }
//+------------------------------------------------------------------+

Beispiel 5. Ein Skript, das eine Zeichenfolge in einem Nutzerprotokoll ausgibt.

• Achten Sie auf die vordefinierten Wörter.

In diesem Code sind die vordefinierten Wörter #property, copyright, link, version, void, OnStart und Print. Klicken Sie im MetaEditor auf eine der Optionen und drücken Sie <F1>, um die integrierte Hilfe zu öffnen.

• In der vom Assistenten erzeugten Funktion OnStart haben wir eine weitere Standardfunktion Print aufgerufen. Mit Hilfe von Parametern (sie werden auch als Argumente bezeichnet), die in Klammern aufgeführt sind, teilen wir der Funktion Print mit, was genau sie drucken soll.

In Beispiel 5 erhält die Funktion Print nur ein Argument: den Text, der in Anführungszeichen geschrieben wird. Im allgemeinen Fall kann es mehrere solcher Argumente geben. Zum Beispiel kann diese Druckfunktion mit einer beliebigen Anzahl von Parametern (bis zu 64) aufgerufen werden.

Wenn eine Funktion mehrere Parameter erhalten muss, sollten diese Parameter durch ein Komma getrennt werden, wie in Beispiel 6:

Print("Hello, MQL5 World!", " I have written my own program. ", "Hooray!");

Beispiel 6. Funktion mit drei Parametern

Nach jedem Komma, das die Parameter voneinander trennt, können Sie ein Zeilenumbruchzeichen einfügen (mit der <Eingabetaste>), damit Sie nicht in Anführungszeichen verwickelt werden.

Achten Sie auch auf Leerzeichen innerhalb des zweiten Arguments. Die Funktion Print „verschmilzt“ ihre Argumente zu einer einzigen großen Zeile, sodass der Programmierer auf alle Satzzeichen und zusätzlichen Trennzeichen zwischen den Wörtern achten muss.

Die Funktion OnStart wird automatisch einmal beim Start des Skripts oder Dienstes ausgeführt.

Wir kompilieren und führen das Skript auf die bereits bekannte Weise aus.

Abbildung 9. Erste nützliche Aktion: Ausgabe einer Zeichenkette in ein Protokoll.

Schlussfolgerung

Expert Advisors und Indikatoren haben ebenfalls vordefinierte Funktionen, allerdings mit anderen Namen. Ihre Funktionsweise ist dieselbe wie die der Skriptfunktionen: Unser Code wird hauptsächlich intern geschrieben, und die Eigenschaften werden extern geschrieben. Aber es gibt auch Unterschiede.

Zum Beispiel werden einige Funktionen in Expert Advisors und Indikatoren vom Terminal bei jedem Tick ausgeführt und nicht nur einmal als OnStart.

Daher schlage ich vor, dass diejenigen, die überprüfen wollen, was sie aus dem Artikel gelernt haben (und ihr Wissen auffrischen wollen), ein wenig „Hausforschung“ auf eigene Faust betreiben:

1. Verwenden Sie den Assistenten zur Dateierstellung, um alle anderen Programmtypen zu erstellen, die in den Beispielen in diesem Artikel nicht behandelt werden.
   
2. Überlegen Sie, ob Sie mit den im Artikel beschriebenen Werkzeugen herausfinden können, welche Funktionen in welcher Reihenfolge aufgerufen werden, wenn die einzelnen Programmtypen starten.
3. Als zusätzliche Aufgabe können Sie prüfen, was passiert, wenn:
   
• Sie fügen die Funktion OnStart zu Indikatoren und Expert Advisors hinzu
• Sie fügen die Funktionen, die der Assistent für andere Programmtypen erstellt, in Skripte und Dienste ein
  

Vielleicht bringen diese Studien Sie auf neue Ideen und helfen Ihnen, besser zu verstehen, wie genau Programme in der Sprache MQL5 funktionieren.

Ich wünsche Ihnen viel Glück. Bis bald in den nächsten Artikeln!