Lernen Sie warum und wie Sie Ihr algorithmisches Handelssystem entwerfen
1 303
0
Einführung
Wir können ohne Zweifel sagen, dass die Bedeutung des Programmierens oder Kodierens jeden Tag in allen Bereichen unserer Welt zunimmt. So können wir beobachten, wie das Programmieren oder Kodieren dazu beitragen kann, unser Leben zu erleichtern und nicht nur unser Leben einfach zu machen, sondern auch genaue Ergebnisse zu garantieren, entsprechend dem, was Sie wollen und was Sie vorher bestimmt haben.
Wenn es um die Welt des Handels geht — dieses großartige Feld und die Karriere — können wir sagen, dass die Programmierung oder Kodierung unseren Handel einfach und systematisch durch erstellte Programme macht, die dazu beitragen, uns diese Leichtigkeit und Automatisierung zu geben, sobald wir ein genaues und gutes Programm mit dem abgeschlossen haben, was wir von diesem Programm erwarten und erhalten wollen. Die Welt des Programmierens kann uns also viele Vorteile bieten, aber meiner Meinung nach ist der wichtigste Vorteil des Programmierens für den Handel, dass es Ihnen hilft, diszipliniert zu sein, denn wie wir alle als Händler wissen, ist es immer eine Herausforderung, diszipliniert mit unseren Handelsentscheidungen zu sein. Disziplin ist eine großartige und wichtige Eigenschaft, die sich auf unsere Handels- und Investitionsergebnisse auswirkt, also ist es keine Option, beim Handel diszipliniert zu sein. Wie ich immer zu sagen pflege: Disziplin ist der Schlüssel zu Ihrem Erfolg im Handel und im ganzen Leben. Einfach ausgedrückt bedeutet Disziplin, dass man das, was man tun muss, zum richtigen Zeitpunkt und unabhängig von den Umständen tut. Wenn wir also ein Werkzeug finden, das uns dabei hilft, müssen wir aufmerksam sein und lernen, was das ist. Und das richtige Werkzeug dafür ist die Codierung.
Wie wir alle wissen, sind Emotionen das, was uns am meisten davon abhält, beim Handel diszipliniert zu sein, und wir müssen diese Emotionen vermeiden oder die negativen Auswirkungen dieser Emotionen auf unsere Handelsentscheidungen vermeiden. Ich möchte, dass Sie sich vorstellen, dass Sie ein System haben, das für Sie mit den von Ihnen vorbestimmten Parametern arbeitet, ohne dass der Mensch eingreift. In diesem Fall werden also die negativen Auswirkungen von Emotionen auf unsere Handelsentscheidungen vermieden. Die gute Nachricht ist, dass wir ein Werkzeug haben, das uns dabei hilft. Hier werde ich über MQL (MetaQuotes Language) für die MetaTrader-Plattform schreiben. Diese großartige Programmiersprache oder dieses Tool hilft uns, unser Handelssystem mit unseren spezifischen Parametern zu entwerfen, die bestimmte Aktionen oder bestimmte Handelsentscheidungen garantieren.
Wenn Sie mehr über dieses Konzept erfahren möchten, lassen Sie uns ein Beispiel anführen. Nehmen wir an, es gibt zwei Anleger (A und B), deren Handelsstrategie dieselbe ist, nämlich Kaufen und Halten während eines Aufwärtstrends und Verkaufen bei einer Trendumkehr, aber jeder von ihnen verhält sich anders — Anleger A ist diszipliniert, Anleger B nicht. Sehen Sie sich die folgenden Zahlen an:
Also, nach dem vorherigen Beispiel, ist es offensichtlich, dass Disziplin wichtig für das gute Ergebnis ist, und ein Mangel an Disziplin zu schlechten Ergebnissen führen wird.
Und durch diesen Artikel teile ich mit Ihnen das einfache Handelssystem Simple Moving Averages Crossover, damit Sie lernen können Ihr eigenes zu erstellen, indem ich einige der Grundlagen der MQL5-Codierung mit Beispielen vorstelle, um diese Grundlagen zu üben und Ihnen ein tiefgehendes Verständnis zu vermitteln. Das Ziel ist es, Ihnen einen Überblick darüber zu geben, was Sie mit diesem großartigen Tool tun können.
Das Hauptziel dieses Artikels ist es, Anfängern zu zeigen, wie sie ihr algorithmisches Handelssystem in MQL5 entwerfen können, indem sie einige der Grundlagen von MQL5 für eine einfache Handelssystem-Idee lernen, die in diesem Artikel Schritt für Schritt kodiert wird, nachdem einige der MQL5-Grundlagen erklärt wurden. Wir werden sie durch Skripte kodieren und dann das Ergebnis nach der Codeausführung präsentieren. Um Ihr Verständnis zu verbessern, empfehle ich Ihnen, das, was Sie hier lesen, selbst anzuwenden und zu kodieren, da dies Ihnen helfen wird, die Konzepte der erwähnten Codes tiefgreifend zu verstehen. Und beachten Sie, dass alle in diesem Artikel erstellten Codes, Programme und Handelsstrategien nur für Ausbildungszwecke und nicht für andere Zwecke bestimmt sind. Und beachten Sie, dass wir MQL5 verwenden werden, um Codes zu schreiben.
Was wir brauchen, um unseren algorithmischen Handel zu entwickeln
In diesem Teil werde ich erwähnen, was wir als Werkzeuge brauchen und was wir über diese Werkzeuge wissen wollen:
- Die MetaTrader 5 Plattform, auch bekannt als MetaTrader 5 Terminal. Über das Terminal können wir Aufträge ausführen und unsere Codes testen. Und MetaTrader ist die beliebteste Handelsplattform.
Ein Demokonto. Sie können bei Ihrem Broker ein Demokonto eröffnen, um mit virtuellem Geld Ihre Handelsstrategien risikofrei, aber in der gleichen Marktumgebung zu testen. Bitte stellen Sie sicher, dass Sie dieses Demokonto und nicht Ihr echtes Konto für die Codierung verwenden, da Sie Programme erstellen und ausführen müssen, die Transaktionen auf Ihrem Konto ausführen werden.
MetaQuotes Language Editor, wo wir unsere Codes oder Programme schreiben werden. Die folgenden Screenshots zeigen, wie Sie ihn öffnen, da er mit MetaTrader installiert ist. Es gibt drei Möglichkeiten, ihn zu öffnen.
- Klicken Sie auf das Menü Extras und dann auf MetaQuotes Language Editor:
Oder klicken Sie auf das Editor-Icon
Oder drücken Sie die Taste F4 auf der Tastatur, während das Terminal geöffnet ist.
Der folgende Screenshot zeigt, wie es aussieht, und hier wird die meiste Arbeit sein, um unsere Programme zu schreiben und unsere Handelssysteme zu entwerfen.
Nun müssen wir diesen Editor verwenden, um unseren ersten Code zu schreiben. Folgen Sie also den folgenden Schritten, um zu erfahren, wie das geht.
Klicken Sie auf "Neu", dann finden Sie mehr als einen Programmtyp zur Auswahl:
Was wir hier in diesem Artikel erwähnen müssen, sind: Expert Advisor, nutzerdefinierte Indikatoren und Skripte.
- Expert Advisor: EA ist ein Programm im Terminal, das für die Automatisierung von Analyse- und Handelsprozessen gemäß den von Ihnen eingestellten Parametern entwickelt und verwendet wird.
- Nutzerdefinierte Indikator: ist ein kodiertes Programm, das im Wesentlichen für die grafische Darstellung von vorläufig berechneten Abhängigkeiten bestimmt ist.
- Skript: ist ein Programm, das für die einmalige Ausführung einer beliebigen Aktion bestimmt ist, es kann sowohl analytische als auch Handelsfunktionen erfüllen, und im Gegensatz zu Expert Advisors wird es auf Anfrage und nicht nach Ticks ausgeführt.
Das Programm Hello World!
In diesem Teil werden wir lernen, wie wir unser erstes Programm und unseren ersten Code in MQL5 schreiben. Alle Anfänger im Programmieren oder Kodieren beginnen ihre Reise mit dem "Hello World"-Code. Wir beginnen also damit, ein Programm zu schreiben, das auf dem Terminalbildschirm "Hello World" ausgibt. Los geht's...
Öffnen Sie den MetaEditor wie oben gezeigt, klicken Sie auf New, wählen Sie aus den Optionen (Skript) und klicken Sie dann auf Weiter.
Nachdem Sie auf "Weiter" geklickt haben, wird das folgende Fenster angezeigt. Füllen Sie die Daten des gewünschten Skripts aus:
- Name ist der Name des Skripts
- Autor ist der Ersteller des Skripts
- Link ist Ihr Link
- Parameter sind die Parameter, die Sie für das Skript festlegen müssen, aber wir werden für dieses Skript keine Parameter festlegen, also lassen wir es weg.
Nach dem Klick auf Fertigstellen wird das folgende Fenster geöffnet. Und in diesem Fenster wird unser Programm kodiert. Wie ich schon sagte, müssen wir ein Programm entwerfen, das "Hello World!" im Terminal anzeigt. Also fangen wir an, unseren Code zwischen den beiden geschweiften Klammern zu schreiben.
Hier werden wir verwenden:
- Alert - druckt aus, was ich bestimme oder zeigt eine vorgegebene Meldung im Programm an, die hier in unserem Beispiel "Hello World!" ist.
- "" - um dazwischen zu schreiben, was ich will oder hier die vorgegebene Nachricht "Hello World!" oder etwas anderes.
- ; - um Anweisungen zu trennen.
Unser Code wird der gleiche sein wie:
//+----------------------------------------------------------+ //| Hello World!.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+----------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+----------------------------------------------------------+ //| Script program start function | //+----------------------------------------------------------+ void OnStart() { Alert("Hello World!"); } //+----------------------------------------------------------+
Nachdem wir unseren Code geschrieben haben, klicken wir auf Kompilieren und stellen sicher, dass keine Fehler und Warnungen vorhanden sind. Die Registerkarte Fehler muss nach dem Kompilieren Ihres Codes fehlerfrei sein, um sicherzustellen, dass Ihr Programm genauso läuft, wie ich es im folgenden Bild erwähne. Gehen Sie dann mit F4 zum Terminal, um unseren Code zu testen.
Handelsstrategie-Idee (zwei einfache gleitende Durchschnittsübergänge)
In diesem Teil werde ich Ihnen eine Handelsstrategie-Idee vorstellen, die nur zu Lehrzwecken dient. Sie soll Ihnen helfen, die Grundlagen von MQL5 zu erlernen und zu verstehen, wie man in MQL5 programmiert.
Haftungsausschluss
Alle Informationen werden in der vorliegenden Form ausschließlich zu Informationszwecken bereitgestellt und sind nicht für Handelszwecke oder Beratung gedacht. Die Performance der Vergangenheit ist keine Garantie für zukünftige Ergebnisse. Wenn Sie sich dafür entscheiden, diese Materialien für Handelskonten zu verwenden, tun Sie dies auf eigenes Risiko.
Bei dieser Strategie wird versucht, mit dem Trend zu handeln, indem das Signal von zwei einfachen gleitenden Durchschnittsindikatoren als Bestätigung verwendet wird:
- Der einfache gleitende Durchschnitt ist ein nachlaufender technischer Indikator, der den durchschnittlichen Schlusskurs einer bestimmten Periode berechnet, und er ist ein nachlaufender, da sein Signal nach dem Signal der Preisaktion kommt.
- Die Strategie ist wie folgt:
- Wenn der kürzere einfache gleitende Durchschnitt (seine Periode ist 20) den längeren einfachen gleitenden Durchschnitt (seine Periode ist 50) nach oben kreuzt, um dann über ihm zu liegen, ist das das Signal zum Kaufen.
- Wenn der kürzere einfache gleitende Durchschnitt (seine Periode ist 20) den längeren einfachen gleitenden Durchschnitt (seine Periode ist 50) nach unten kreuzt, um dann darunter zu liegen, ist das das Signal zum Verkaufen.
Hier müssen wir ein Programm entwerfen, um dies zu tun.
Algorithmisches Handelssystem - die Blaupause
In diesem Teil werde ich über einen sehr wichtigen Schritt sprechen, den Sie tun müssen, wenn Sie Ihr System einfach und reibungslos programmieren wollen. Dieser Schritt besteht darin, eine Blaupause für Ihre Strategie und Handelsidee in Form einer Abfolge von Schritten zu erstellen, was Ihr System genau tun soll, und das können Sie zum Beispiel auf einem Chart tun, das Ihnen eine klare Blaupause gibt. Und hier ist ein Beispiel für unser System, das Kreuzen von zwei gleitenden Durchschnitten, um in einer klaren Art und Weise zu sehen, was wir brauchen, um Code und was wir erwarten, dass von diesem System zu bekommen.
Lassen Sie uns zunächst einige der Grundlagen von MQL5 verstehen und dann das verwenden, was wir für den Entwurf brauchen.
Variablen und deren Typen und wie wir sie verwenden können
In diesem Teil werden wir sie identifizieren und verstehen:
- Was sind Variablen?
- Die Arten von Variablen.
- Wie können wir sie verwenden?
Im Allgemeinen können die Datenwerte in einem Programm konstant oder variabel sein. Wenn Werte variabel sind, können sie vom Programm und vom Nutzer geändert werden. Eine Variable ist ein Speicherplatz. Sie hat einen Namen, der mit dieser Stelle verbunden ist. Der Speicherplatz wird also zur Aufnahme von Daten verwendet. Ein Programm in MQL5 kann Dutzende und Hunderte von Variablen enthalten. Eine sehr wichtige Eigenschaft jeder Variablen ist die Möglichkeit, ihren Wert in einem Programm zu verwenden. Die Einschränkung dieser Möglichkeit hängt mit dem Variablenbereich zusammen, d.h. dem Ort im Programm, an dem der Wert der Variablen verfügbar ist. Jede Variable hat ihren Geltungsbereich.
Je nach Anwendungsbereich gibt es in MQL5 zwei Arten von Variablen, lokale und globale. Eine lokale Variable ist eine Variable, die innerhalb einer Funktion deklariert wird. Der Geltungsbereich lokaler Variablen ist der Körper der Funktion, in der die Variable deklariert ist. Eine lokale Variable kann durch eine Konstante oder einen Ausdruck, der ihrem Typ entspricht, initialisiert werden. Globale Variablen werden außerhalb aller Funktionen deklariert. Der Geltungsbereich von globalen Variablen ist das gesamte Programm. Eine globale Variable kann nur durch eine Konstante initialisiert werden, die ihrem Typ entspricht (und nicht durch einen Ausdruck). Globale Variablen werden nur einmal initialisiert, bevor die Ausführung spezieller Funktionen angegeben wird.
Unabhängig vom Anwendungsbereich der Variablen werden wir uns nun die folgenden Variablentypen ansehen:
- int ist ein numerischer Typ; es gibt verschiedene Typen von Ganzzahlen, um numerische Werte unterschiedlicher Länge zu speichern.
- double. Um ein Programm zu erstellen, das mit den im Handel verwendeten Zahlen umgehen kann, wird ein Datentyp benötigt, der in der Lage ist, Gleitkommazahlen zu verwalten. MetaTrader bietet also die folgenden Datentypen an, um mit diesen Daten umzugehen: float und double. Der Unterschied zwischen ihnen besteht in den im Speicher zugewiesenen Bytes, 4 für float und 8 für double, woraus sich die folgenden Mindest- und Höchstwerte ergeben:
- float - minimal 1,175494351e-38, maximal 3,402823466e+38
- double - minimal 2,2250738585072014e-308, maximal 1,7976931348623158e+308
Um diese Datentypen zu deklarieren, verwenden Sie die Schlüsselwörter float und double. - string ist ein sehr wichtiger Datentyp, der auch in der MQL5-Codierung häufig verwendet wird. String ermöglicht die Speicherung und Manipulation einer beliebigen alphanumerischen Zeichenfolge.
- bool - Boolean ist ein logischer Typ, der entweder den Wert true (wahr) oder false (falsch) annehmen kann.
Nehmen wir ein Beispiel für die Verwendung einer Variablen:
//+------------------------------------------------------------------+ //| Variables.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { int myInteger = 5; double myDouble = 10.56; string myString = "My name is Mohamed"; bool myBoolean = true; Alert(myInteger); Alert(myDouble); Alert(myString); Alert(myBoolean); } //+------------------------------------------------------------------+
Nach dem Kompilieren des vorherigen Codes, wenn Sie schreiben, was ich oben erwähnt habe, werden Sie keine Fehler oder Warnungen finden und Sie müssen das Alert-Fenster wie unten Bildschirmfoto sehen.
Ein weiteres Beispiel für die Verwendung von Variablen.
- Der entsprechende Wert von message1
- Den entsprechenden Wert von C
- Den äquivalenten Wert von result
- Den Gegenwert von message2
//+------------------------------------------------------------------+ //| Variables 2.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { int A = 10; int B = 5; int C; double var1 = 2.5; double var2 = 4; double result = var1 / var2; string greeting = "Hello"; string space = " "; string name = "Mohamed"; string message1; string message2; C = A + B; message1 = greeting + space + name; message2 = "Value of A is: " + string(A); Alert(message1); Alert(C); Alert(result); Alert(message2); } //+------------------------------------------------------------------+
Boolesche Operationen
Boolean: gibt bei einer logischen Operation einfach true oder false zurück.
- == bedeutet gleich
- != bedeutet ungleich
- < bedeutet kleiner als
- <= bedeutet kleiner oder gleich als
- > bedeutet größer als
- >= bedeutet größer oder gleich als
//+------------------------------------------------------------------+ //| Boolean Operations.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { bool result = 4 < 5; Alert (result); //true } //+------------------------------------------------------------------+
Hier muss er bei die Alert-Nachricht true zurückgeben, da 4 < 5.
Die While-Schleife
Der while-Operator besteht aus einem geprüften Ausdruck und dem Operator, der erfüllt sein muss. Wenn der Ausdruck wahr ist, wird der Operator so oft ausgeführt, bis der Ausdruck falsch wird. Im folgenden Beispiel können wir verstehen, dass zuerst eine Warnung am Anfang erfolgt, um den Anfang und das Ende der Schleife zu kennen, dann wird das Programm den Wert des Zählers überprüfen und seinen Wert anzeigen, wenn er kleiner als 3 ist. Dann addiert es eine Zahl zum vorherigen Ergebnis, bis es in diesem Fall = oder > 3 ist, und gibt dann die letzte Meldung aus, dass die Schleife beendet wurde. In der Warnmeldung dieses Codes werden also die folgenden Meldungen angezeigt: Start des Skripts, 1, 2, Schleife ist beendet.//+------------------------------------------------------------------+ //| While Loop.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //While (Loop) Alert("Start of script"); int counter = 1; while(counter < 3) //true? { Alert(counter); counter = counter + 1; } Alert("Loop has finished"); }
Die for-Schleife
Der for-Operator besteht aus drei Ausdrücken und einem ausführbaren Operator:
for(Ausdruck1; Ausdruck2; Ausdruck3)
Operator;
Ausdruck1 beschreibt die Initialisierung der Schleife. Ausdruck2 prüft die Bedingungen für den Schleifenabbruch. Solange Ausdruck2 wahr ist, wird der Schleifenkörper for ausgeführt. Die Schleife wiederholt den Ausdruck2 so lange, bis er falsch wird. Ist er falsch, wird die Schleife beendet und die Kontrolle wird an den nächsten Operator übergeben. Ausdruck3 wird nach jeder Iteration berechnet.
Nach dem folgenden Beispiel einer for-Schleife können wir also erwarten, dass die Ausführung des Codes fünf Hello-Nachrichten ergeben wird (I =0, I = 2, ............,I = 4), dann wird es = 5, also wird die Schleife beendet.
//+------------------------------------------------------------------+ //| For Loop.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { for(int i=0; i<5 ; i++) { Alert("Hello"); } } //+------------------------------------------------------------------+
Die IF, Else-Anweisung
Der Operator if - else wird verwendet, wenn eine Entscheidung getroffen werden muss. Formal sieht die Syntax wie folgt aus:
if (Ausdruck)
Operator1
else
Operator2
Wenn der Ausdruck wahr ist, wird Operator1 ausgeführt und die Kontrolle wird an den Operator übergeben, der auf Operator2 folgt (Operator2 wird nicht ausgeführt). Wenn der Ausdruck falsch ist, wird Operator2 ausgeführt.
Beispiel: Gemäß dem folgenden Beispiel müssen wir zuerst eine Meldung mit dem Bid-Wert erhalten, dann bestimmen wir, ob der Bid-Wert > 1,146600 ist, dann werden wir mit "Der Preis liegt über 1,146600 => KAUFEN" alarmiert. Wenn nicht, dann werden wir mit "Der Preis ist unter 1.146600 => VERKAUFEN" alarmiert. Im Folgenden sehen Sie den Code und das Ergebnis der Ausführung.
//+------------------------------------------------------------------+ //| If-else statement.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { double level = 1.146600; double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); Alert("Bid Price = " + string(Bid)); if(Bid > level) { Alert ("The price is above " + string(level) + " -> BUY"); } // What if the condition is false and we need to take an action also here we can use else function instead of writing another if code else { Alert ("The price is below " + string(level) + " -> SELL"); } } //+------------------------------------------------------------------+
Eingaben des Händlers
In diesem Teil werden wir lernen, wie wir unsere Eingaben oder bevorzugten Parameter für das Programm bestimmen können, anstatt den Code anzupassen.
Properties (#property): Jedes MQL5-Programm erlaubt die Angabe zusätzlicher spezifischer Parameter namens #property, die dem Client-Terminal bei der korrekten Bedienung der Programme helfen, ohne dass diese explizit gestartet werden müssen.
script_show_inputs: Zeigt ein Fenster mit den Eigenschaften an, bevor das Skript ausgeführt wird, und schaltet dieses Bestätigungsfenster ab.
Eingabevariablen: Die Speicherform input definiert die externe Variable. Die Speicherform input wird vor dem Datentyp angegeben.
//+------------------------------------------------------------------+ //| Trader Inputs.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 10; input int StopLoss = 10; void OnStart() { double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double TakeProfitLevel = Bid + TakeProfit * 0.00001; // 0.00001 (5 digits broker, so multiplied by 10) double StopLossLevel = Bid - StopLoss * 0.00001; Alert("Price now = " + string(Bid)); Alert ("TakeProfitLevel = ", TakeProfitLevel); Alert ("StopLossLevel = ", StopLossLevel); } //+------------------------------------------------------------------+
Erteilen von Aufträgen
In diesem Teil werde ich Ihnen zeigen, wie Sie Ihren Code schreiben, um einen Auftrag zu erteilen:
//+------------------------------------------------------------------+ //| TEST.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs #include <Trade\Trade.mqh> CTrade trade; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 150; input int StopLoss = 100; void OnStart() { double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double Balance = AccountInfoDouble(ACCOUNT_BALANCE); double Equity = AccountInfoDouble(ACCOUNT_EQUITY); double TakeProfitLevel = (Ask+TakeProfit*0.00001); double StopLossLevel = (Ask-StopLoss*0.00001); if(Equity >= Balance) trade.Buy(0.01,NULL,Ask,StopLossLevel,TakeProfitLevel,NULL); for (int i=PositionsTotal()-1; i>=0; i--) { ulong ticket = PositionGetTicket(i); ENUM_POSITION_TYPE position = ENUM_POSITION_TYPE(PositionGetInteger(POSITION_TYPE)); Alert (" Order Ticket # ", ticket); Alert("TakeProfit = ", TakeProfitLevel); Alert("StopLoss = ", StopLossLevel); } } //+------------------------------------------------------------------+
Technik der Fehlerbehandlung
Wenn das Programm läuft, kann jeder mit Abstürzen konfrontiert werden, und etwas ist schief gelaufen. Daher müssen wir diese Technik in unseren Code einbauen, um jeden ausgeführten Auftrag oder Code zu überprüfen und zu warnen, wenn etwas schief gelaufen ist. Mit anderen Worten, es ist eine Schutztechnik für den Händler, um ihn und seinen Fonds vor jeder unangemessenen Situation zu schützen.
//+------------------------------------------------------------------+ //| TEST.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs #include <Trade\Trade.mqh> CTrade trade; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 150; input int StopLoss = 100; void OnStart() { double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double Balance = AccountInfoDouble(ACCOUNT_BALANCE); double Equity = AccountInfoDouble(ACCOUNT_EQUITY); double TakeProfitLevel = (Ask+TakeProfit*0.00001); double StopLossLevel = (Ask-StopLoss*0.00001); if(Equity >= Balance) trade.Buy(0.01,NULL,Ask,StopLossLevel,TakeProfitLevel,NULL); for (int i=PositionsTotal()-1; i>=0; i--) { ulong ticket = PositionGetTicket(i); ENUM_POSITION_TYPE position = ENUM_POSITION_TYPE(PositionGetInteger(POSITION_TYPE)); if (ticket <= 0) { Alert("Error!"); //in Case of error and the order did not open, appears "Error!" } else { Alert("Your ticket # is: " + string(ticket)); Alert("TakeProfit = ", TakeProfitLevel); Alert("StopLoss = ", StopLossLevel); } } } //+------------------------------------------------------------------+
Schließen von Positionen
In diesem Teil werden wir einen Code zum Öffnen und Schließen einer Position erstellen, um zu lernen, wie man eine Position schließt.//+------------------------------------------------------------------+ //| TEST.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs #include <Trade\Trade.mqh> CTrade trade; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 150; input int StopLoss = 100; void OnStart() { double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double Balance = AccountInfoDouble(ACCOUNT_BALANCE); double Equity = AccountInfoDouble(ACCOUNT_EQUITY); double TakeProfitLevel = (Ask+TakeProfit*0.00001); double StopLossLevel = (Ask-StopLoss*0.00001); trade.Buy(0.01,NULL,Ask,StopLossLevel,TakeProfitLevel,NULL); for (int i=PositionsTotal()-1; i>=0; i--) { ulong ticket = PositionGetTicket(i); ENUM_POSITION_TYPE position = ENUM_POSITION_TYPE(PositionGetInteger(POSITION_TYPE)); Alert (" Order Ticket # ", ticket); Alert("TakeProfit = ", TakeProfitLevel); Alert("StopLoss = ", StopLossLevel); Sleep(2000); trade.PositionClose(ticket,-1); Alert("Order Closed..."); } } //+------------------------------------------------------------------+
Anpassen von Positionen durch OrderModify
In diesem Teil werden wir lernen, wie man einen Code erstellt, mit dessen Hilfe man eine Position ändern kann. Damit werden die Eigenschaften der zuvor geöffneten oder schwebenden Aufträgen.
//+------------------------------------------------------------------+ //| TEST.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs #include <Trade\Trade.mqh> CTrade trade; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 150; input int StopLoss = 100; void OnStart() { double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double Balance = AccountInfoDouble(ACCOUNT_BALANCE); double Equity = AccountInfoDouble(ACCOUNT_EQUITY); double TakeProfitLevel = (Ask+TakeProfit*0.00001); double StopLossLevel = (Ask-StopLoss*0.00001); double TakeProfitLevel2 = (TakeProfitLevel+0.00100); double StopLossLevel2 = (StopLossLevel-0.00050); trade.Buy(0.01,NULL,Ask,StopLossLevel,TakeProfitLevel,NULL); for (int i=PositionsTotal()-1; i>=0; i--) { ulong ticket = PositionGetTicket(i); ENUM_POSITION_TYPE position = ENUM_POSITION_TYPE(PositionGetInteger(POSITION_TYPE)); Alert (" Order Ticket # ", ticket); Alert("TakeProfit = ", TakeProfitLevel); Alert("StopLoss = ", StopLossLevel); Sleep(5000); trade.PositionModify(ticket,StopLossLevel2,TakeProfitLevel2); Alert("Order Modified..."); Alert("Modified TakeProfit = ", TakeProfitLevel2); Alert("Modified StopLoss = ", StopLossLevel2); } } //+------------------------------------------------------------------+
Das System der zwei einfachen gleitenden Durchschnitte Crossover
In diesem Teil setzen wir alles zusammen, um das Kreuzen von zwei einfache gleitende Durchschnitten zu programmieren. Das Ganze wird alle das tun, was nach der oben erwähnten Blaupause erforderlich ist.
Hier werden wir einen Expert Advisor wählen, wenn wir ein neues Projekt starten, indem wir im MetaEditor auf "New" klicken.
Um sich an alles zu erinnern, noch einmal die Blaupause von unserm detaillierten Handelssystem:
- Wenn der kürzere einfache gleitende Durchschnitt (seine Periode ist 20) den längeren einfachen gleitenden Durchschnitt (seine Periode ist 50) nach oben kreuzt, ist das das Signal zum Kaufen.
- Wenn der kürzere einfache gleitende Durchschnitt (seine Periode ist 20) den längeren einfachen gleitenden Durchschnitt (seine Periode ist 50) nach unten kreuzt, ist das das Signal zum Verkaufen.
//+------------------------------------------------------------------+ //| SMA crossover.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //create an array for several prices double myMovingAverageArray1[], myMovingAverageArray2[]; //define the properties of MAs - simple MA, 1st 20 / 2nd 50 int movingAverage1 = iMA(_Symbol, _Period, 20, 0, MODE_SMA, PRICE_CLOSE); int movingAverage2 = iMA(_Symbol,_Period,50,0,MODE_SMA,PRICE_CLOSE); //sort the price arrays 1, 2 from current candle ArraySetAsSeries(myMovingAverageArray1,true); ArraySetAsSeries(myMovingAverageArray2,true); //Defined MA1, MA2 - one line - currentcandle, 3 candles - store result CopyBuffer(movingAverage1,0,0,3,myMovingAverageArray1); CopyBuffer(movingAverage2,0,0,3,myMovingAverageArray2); //Check if we have a buy entry signal if ( (myMovingAverageArray1[0]>myMovingAverageArray2[0]) && (myMovingAverageArray1[1]<myMovingAverageArray2[1]) ) { Comment("BUY"); } //check if we have a sell entry signal if ( (myMovingAverageArray1[0]<myMovingAverageArray2[0]) && (myMovingAverageArray1[1]>myMovingAverageArray2[1]) ) { Comment("SELL"); } } //+------------------------------------------------------------------+
Nach der Ausführung des Programms werden auf dem Chart Kommentare mit dem aktuellen Signal (Kauf oder Verkauf) gemäß dieser Strategie angezeigt. Dies ist in der folgenden Abbildung dargestellt:
Aktivieren Sie die Option "Algo-Handel zulassen" und klicken Sie dann auf "OK". Danach wird der Expert Advisor an den Chart angehängt und auf der Registerkarte Journal erscheint eine Meldung, dass er erfolgreich geladen wurde:
So, wir haben unser Automatisierungsprogramm mit dem Kreuzen von zwei einfachen gleitenden Durchschnitten erstellt und ausgeführt. Und was ich hier erwähnen möchte, ist, dass dies ein einfaches Beispiel dafür ist, was wir für unseren Handel kodieren können. Wir können jedoch auch jede andere Handelsstrategie mit diesem großartigen Tool MQL5 programmieren und automatisieren.
Auch hier ist das Hauptziel dieses Artikels nicht, diese Strategie zu verwenden, sondern das Hauptziel ist es, einige der Grundlagen von MQL5 zu lernen und zu erfahren, was wir erstellen können, um uns vorzustellen, was wir tun können und um unseren Handel einfacher und profitabler zu machen. Also, diese Strategie braucht eine Menge von Verbesserungen und wenn Sie es verwenden, wird es allein Ihre Verantwortung sein.
Schlussfolgerung
MQL5 ist ein gutes und großartiges Werkzeug, das uns hilft, unseren Handel einfacher und profitabler zu machen, indem es gute und profitable algorithmische Handelssysteme entwickelt. Ihre Investition in das Erlernen und die Nutzung dieses großartigen Werkzeugs wird sich also in hohem Maße lohnen.
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/10293
Universelles Regressionsmodell für die Prognostizierung von Marktpreisen (Teil 2): Natürliche, technologische und soziale Übergangsfunktionen
Grafiken in der Bibliothek DoEasy (Teil 89): Programmieren von grafischen Standardobjekten, grundlegende Funktionsweise
Erweiterter EA-Konstruktor für MetaTrader - botbrains.app
Websockets für MetaTrader 5 — Unter Verwendung der Windows API
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.