MQL5 Strategietester verstehen und effektiv nutzen

Einführung

Als MQL5-Programmierer oder -Entwickler stellen wir fest, dass wir den Strategietester gut verstehen und nutzen müssen, um effektive Ergebnisse zu erzielen. Mit diesem wertvollen Tool können wir wertvolle Einblicke in Bezug auf die Leistung unserer erstellten MQL5-Programme erhalten, was sich auf die Erzielung besserer Handelsergebnisse auswirkt. Wir stellen also fest, dass wir wichtige Themen gut verstehen müssen, bevor wir unsere Tests durchführen, wie z. B. den Umgang mit allen Fehlertypen, da es ganz normal ist, dass wir als Entwickler Fehler machen, die zu Fehlern führen. Ein weiteres Thema, das wir gut verstehen müssen, ist das Debugging, mit dem wir unsere erstellten Programme interaktiv ausführen können. Dann kommen wir zum wichtigsten und wertvollsten Werkzeug, dem Strategietester, um unsere erstellten Programme mit den interessantesten Funktionen von MetaTrader 5 zu testen und zu bewerten. So wird es eine erstaunliche Lernreise in diesem Artikel, um die wichtigsten Aspekte der Verwendung der MQL5 Strategietester lernen wir es durch die folgenden Themen zu decken:

• Fehler
• Fehlersuche
• Der Strategietester
• Schlussfolgerung

Wir werden versuchen, die wichtigsten Punkte zu diesen Themen zu behandeln, um zu verstehen, womit wir als Programmierer oder Entwickler umgehen müssen. Was ich hier erwähnen muss, ist, dass, wenn wir uns mit diesem Thema beschäftigen, es normal ist, dass alle Leser bereits die MQL5-Programmiersprache kennen und wissen, wie sie ihre Programme codieren können, da dies ein vorausgesetztes Thema ist, das Sie verstehen müssen, um den größten Nutzen aus dem Lesen dieses Artikels zu ziehen. Wenn Sie sich zunächst mit der Sprache vertraut machen möchten, finden Sie die MQL5-Dokumentation. Sie können auch meine anderen Artikel über das Erlernen der Grundlagen der mql5-Programmierung und über die Erstellung von Handelssystemen auf der Grundlage der beliebtesten technischen Indikatoren lesen, und ich hoffe, Sie können Ihnen helfen.

Fehler

In diesem Thema werden wir uns mit Fehlern beschäftigen, die beim Erstellen, Ausführen und Ausführen von MQL5-Programmen auftreten können. Es ist sehr wichtig, dieses Thema zu verstehen, denn MQL5 meldet diese Fehler zwar korrekt, aber wenn wir nicht wissen, was diese Fehler bedeuten oder in welchem Stadium unseres Programms sie auftreten, brauchen wir viel mehr Zeit, um sie zu behandeln oder zu beheben, als wenn wir bereits wissen, was sie bedeuten.

Wir werden dieses Thema auf der Grundlage der Phase unserer Arbeit an der MQL5-Programm, während wir unseren Code zu schreiben gibt es Fehler und Warnungen, die konfrontiert werden können, die Kompilierung Fehler und Warnungen sind. Wir können auch Fehler bei der Ausführung der MQL5 Programm, das die Laufzeit Fehler sind und wir können auch andere Arten von Fehlern, wenn unsere MQL5 Programm versucht, den Handel, die den Handel Server Fehler sind Gesicht. Deshalb werden wir die folgenden Fehlerarten behandeln:

• Kompilierungsfehler und Warnungen
• Ausführungsfehler
• Fehler des Handelsservers

Bevor wir uns mit diesen Fehlern befassen, ist es wichtig, dass wir wissen, wo die Fehler auftauchen. In der MQL5 IDE gibt es ein Toolbox-Fenster im untersten Teil, wenn Sie es standardmäßig finden, können Sie es mit einer der folgenden Methoden anzeigen:

1. Klicken Sie auf Ansicht ==> Wählen Sie Terminal (Toolbox)

2. Drücken von Strg+T auf der Tastatur

3. Klicken auf die Schaltfläche Terminal in der Haupt-Menü

Danach sollten Sie folgendes Bild sehen:

Kompilierungsfehler und Warnungen:

Wenn wir unseren Code für ein bestimmtes Programm schreiben, können wir Fehler machen, und das ist ganz normal, indem wir zum Beispiel eine falsche Syntax schreiben oder Tippfehler haben, was zu Fehlern beim Kompilieren des Codes führt. In diesem Teil werden wir die beliebtesten und am häufigsten auftretenden Fehler dieser Art vorstellen. Das Wichtigste, was Sie wissen müssen, ist, dass das Programm nicht kompiliert werden kann, bis die Fehler beseitigt oder gelöst sind. Ich werde die verbreitetsten Fehler vorstellen, denen wir bei dieser Art von Fehlern begegnen können:

Fehler, ein Semikolon erwartet:

Dieser Fehler tritt auf, wenn wir vergessen haben, ein Semikolon am Ende der Zeile zu schreiben, also ein fehlendes Semikolon haben, oder wenn wir auch eine linke Klammer vergessen haben. Wir müssen diese Arten von Symbolen richtig verwenden, um diese Art von Fehler zu vermeiden. Der folgende Code ist ein Beispiel für diesen Fehler.

Fehler, der falscher Code:

int a=(2+1)

Der Fehler wird wie folgt ausgewiesen:

Kein Fehler, der korrekte Code:

Nachdem wir den Code korrigiert haben, indem wir das Semikolon am Ende der Codezeile hinzugefügt haben, finden wir den korrekten Code wie den folgenden:

int a=(2+1);

Nach dem Kompilieren des Codes wird festgestellt, dass der Fehler behoben ist und der Code ohne Fehler kompiliert wird:

Fehler, ein unerwarteter Token:

Dies ist eine andere Art von Code, die wir häufig konfrontiert und der Grund dafür ist das Vergessen einer rechten Klammer in der letzten Zeile des Codes oder wir können zusätzliche linke Klammer in der vorliegenden Zeile des Codes hinzufügen. Ein Beispiel für diese Art von Fehler ist das folgende:

Fehler, der falscher Code:

int a=(2+1;

Wir können den Fehler, wie wir wissen, auf der Registerkarte „Fehler“ (Errors) in der Toolbox wie folgt sehen:

Kein Fehler, der korrekte Code:

int a=(2+1);

Auf der Registerkarte „Fehler“ werden alle Fehler angezeigt, die nach der Korrektur des Codes durch Hinzufügen der rechten Klammer wie im Folgenden beschrieben auftreten:

Fehler, ein nicht deklarierter Bezeichner:

Diese Art von Fehler tritt auf, wenn wir eine Variable verwenden, ohne sie vorher zu deklarieren, da wir jede neue Variable deklarieren müssen, bevor wir sie verwenden oder ihr einen Wert zuweisen. Deklaration durch Auswahl des richtigen und geeigneten Datentyps, der an diese Variable zurückgegeben werden soll, z. B. Integer oder String. Nachfolgend ein Beispiel für diese Art von Fehler, wenn eine neue Variable verwendet wird, ohne sie zu deklarieren.

Fehler, der falscher Code:

a=5;

Im vorherigen Code haben wir die Variable (a) verwendet, indem wir ihr 5 zugewiesen haben, ohne sie zu deklarieren. Wenn wir also diesen Code wie folgt kompilieren, werden wir den nicht deklarierten Bezeichnerfehler finden:

Wie wir sehen können, kann die Genauigkeit der Fehlerbeschreibung sehr hilfreich sein, da sie nicht nur den Fehler meldet, sondern auch die Variable „a“ angibt, die der Grund für diesen Fehler ist.

Kein Fehler, der korrekte Code:

int a=5;

Nach dem Kompilieren dieses korrekten Codes werden wir in demselben Bild, das wir zuvor auf der Registerkarte „Fehler“ der Toolbox erwähnt haben, keine Fehler mehr finden.

Unausgeglichene linke Klammerfehler:

Diese Art von Fehler tritt auf, wenn die richtige Klammer fehlt oder eine zusätzliche rechte Klammer verwendet wird. Wir können diesen Fehler anhand des folgenden Beispiels finden.

Fehler, der falscher Code:

   bool a=7;
   if (a=5
   a=5;

Im vorherigen Code finden wir, dass durch das Vergessen der rechten Klammer der Fehler „unausgewogene linke Klammer“ (unbalanced left parenthesis) zusätzlich zu dem Fehler „irgendein Operator erwartet“ derselbe ist wie im folgenden Bild:

Kein Fehler, der korrekte Code:

   bool a=7;
   if (a=5)
   a=5;

Nachdem wir den Code korrigiert haben, werden wir feststellen, dass er ohne Fehler kompiliert wurde.

Unerwarteter Fehler beim Programmende:

Manchmal vermissen wir eine schließende Klammer in unserem Code und dies führt zu einem unerwarteten Fehler am Programmende. Wir müssen unseren Code überprüfen, um zu sehen, was wir hinzufügen müssen, oder wir müssen sicherstellen, dass jede öffnende Klammer eine schließende Klammer hat, um diesen Fehler zu lösen. Im Folgenden finden Sie ein Beispiel für diesen Code.

Fehler, der falscher Code:

void OnStart()
  {
   bool a=7;
   if (a=5)
   a=5;

Wenn wir den Code genauso schreiben wie den vorherigen Codeblock und dabei die schließende Klammer nach der letzten Zeile (a=5) weglassen, können wir den Fehler „unerwartetes Programmende“ und einen weiteren Fehler „unausgewogene Klammern“ wie in der folgenden Abbildung finden:

Kein Fehler, der korrekte Code:

void OnStart()
  {
   bool a=7;
   if (a=5)
   a=5;
   }

Nachdem wir den Code durch Hinzufügen der schließenden Klammer korrigiert haben, werden wir feststellen, dass der Code ohne Fehler kompiliert wurde.

Ausdrücke sind bei einem Fehler im globalen Bereich nicht zulässig:

Dieser Fehler tritt auf, wenn wir eine linke Klammer in einem zusammengesetzten Operator vermissen oder wenn wir eine Anweisung oder einen Ausdruck außerhalb des Anwendungsbereichs einer bestimmten Funktion schreiben, da wir nur Ausdrücke innerhalb des Anwendungsbereichs der Funktion verwenden müssen. Das folgende Beispiel bezieht sich auf diese Art von Fehler.

Fehler, der falscher Code:

   int a=(7+5);
   if (a<7)
   
   a=7;
   }

Im vorherigen Code haben wir die „}“-Öffnung vergessen, die den Anwendungsbereich änderte und zu dem den Fehler „Ausdrücke sind in einem globalen Bereich nicht zulässig“ (Expressions are not allowed on a global scope) führt. Der folgende Fehler wird auf der Registerkarte Fehler angezeigt.

Kein Fehler, der korrekte Code:

   int a=(7+5);
   if (a<7)
   {
   a=7;
   }

Nach der Korrektur des Codes auf die gleiche Weise wie bei dem vorherigen Codeblock werden wir feststellen, dass der Code ohne Fehler kompiliert wurde.

Fehler, eine falsche Anzahl der Parameter:

Diese Art von Code tritt auf, wenn wir eine bestimmte Funktion mit bestimmten Parametern verwenden und diese Parameter nicht richtig spezifizieren, indem wir zu viele oder nicht genügend Parameter angeben. Dieser Fehler tritt auf, wenn wir die vordefinierte Funktion oder die von uns erstellten Funktionen verwenden. Im Folgenden finden Sie ein Beispiel für diesen Fehler.

Code mit Fehler:

Wenn wir eine Funktion „myVal“ erstellt haben, um einen ganzzahligen Wert des Ergebnisses der Summierung von zwei ganzzahligen Werten zurückzugeben, was bedeutet, dass wir zwei Parameter in dieser Funktion haben? Wenn wir also diese Funktion mit anderen Parametern als diesen beiden Parametern aufrufen, erhalten wir die gleiche Art von Fehler wie bei dem folgenden Code

void OnStart()
  {
   int example=myVal(10);
  }
//+------------------------------------------------------------------+
int myVal(int a, int b)
  {
   return a+b;
  }

Beim Kompilieren des vorherigen Codes erhalten wir folgenden Fehler:

Code ohne Fehler:

Um diesen Code korrekt zu schreiben, müssen wir die angegebenen Parameter dieser erstellten Funktion wie folgt verwenden:

void OnStart()
  {
   int example=myVal(10,20);
  }
//+------------------------------------------------------------------+
int myVal(int a, int b)
  {
   return a+b;
  }

Nach dem Kompilieren dieses korrekten Codes werden wir keine Fehler mehr finden.

Fehler, ein fehlender Operator:

Diese Art von Fehlern tritt auf, wenn wir einen Operator an einer bestimmten Stelle erwartet wird, indem wir ihn vergessen oder falsch platziert haben. Im Folgenden finden Sie ein Beispiel für einen solchen Fehler.

Code mit Fehler:

int a= 7 10;

Im vorherigen Code haben wir einen Operator zwischen den beiden Zahlen vergessen, und das ist der Grund dafür, dass wir die Fehlermeldung „Operator erwartet“ (some operator expected) erhalten:

Code ohne Fehler:

int a= 7+10;

Nachdem wir den Code durch Hinzufügen des (+) korrigiert haben, werden wir feststellen, dass der Code ohne Fehler kompiliert wird.

Die erwähnten Fehler sind die verbreitetsten Fehler in dieser Art als Kompilierungsfehler, aber wir sagten, dass es Kompilierungswarnungen gibt. Wir müssen auch lernen, was sie sind, sie werden zu Informationszwecken gezeigt, aber sie sind keine Fehler. Der folgende Beispielcode zeigt, dass auf der Registerkarte Fehler eine Warnung angezeigt wird

int a;

Wenn wir den vorherigen Code kompilieren, erhalten wir eine Warnung, dass die Variable „a“ nicht verwendet wird, da wir eine Variable „a“ deklariert haben, diese aber nicht verwenden und ihr keinen Wert zuweisen. Die folgende Warnung ist als Bild dargestellt

Sie können alles in MQL5 prüfen. Der folgende Link aus der Dokumentation ist für weitere Informationen:

• Fehler bei der Kompilierung
• Kompilationswarnungen

Einige Tipps, die sehr nützlich und hilfreich sein können, um mit diesen Fehlern umzugehen, wenn sie auftreten:

• Beheben Sie die Fehler immer vom Anfang an, da sie Folgefehler je nach Fehlerursache verursachen können.
• Ein Doppelklick auf die Zeile mit der Fehleranzeige in der Registerkarte „Fehler“ der Toolbox führt direkt zu der Codezeile, in der das Problem auftritt.

Jetzt haben wir die Fehler kennengelernt, die in der ersten Phase beim Schreiben des Codes des MQL5-Programms auftreten können. Wir werden zur zweiten Stufe übergehen, die Fehler betrifft, die bei der Ausführung des Programms auftreten, d. h. Laufzeitfehler.

Laufzeitfehler:

Wie bereits erwähnt, sind Laufzeitfehler die Arten von Fehlern, die während der Ausführung eines MQL5-Programms auftreten. Diese Fehler verhindern nicht, dass der Code zwar fehlerfrei kompiliert wird, aber er wird nicht so ausgeführt oder betrieben, wie Sie es brauchen oder erwarten. Wir können diese Fehler im Protokoll als gedruckte Meldungen mit dem Grund für den Fehler und die Zeile, die den Fehler im Quellcode hat auch finden.

Beispiele für diese Fehler:

Fehlercode	Grund des Fehlers
4007	Zu kleine Arraygröße für die geforderte Größe oder der Versuch der Größenänderung eines statischen Arrays
4101	Falscher Identifikator des Charts.
4301	Unbekanntes Symbol
4754	Order ist nicht gefunden
5120	Interner Datenbankfehler

Wenn Sie bemerkt haben, dass wir einen Fehlercode haben werden, da MQL5 alle Laufzeitfehler durch Codes definiert hat, um einfach zu identifizieren, und Sie können diese Codes finden, indem Sie die Funktion GetLastError() verwenden, können Sie eine Fehlerbehandlungsmethode zu Ihrem Programm hinzuzufügen. Wir können diese Fehler in der Registerkarte „Journal“ sehen, während wir testen oder in der Registerkarte „Experte“, während wir das Programm an das Diagramm anhängen, um in der aktuellen Zeit ausgeführt zu werden, und Sie können alle Laufzeitfehler mit allen Codes in der MQL5-Dokumentation über den folgenden Link sehen:

https://www.mql5.com/de/docs/constants/errorswarnings/errorcodes

Ich muss hier erwähnen, dass das Programm die Ausführung nach dem Laufzeitfehler nicht beendet, außer bei einigen kritischen Fehlern, die die Ausführung beenden, wie z. B. einem Array-Fehler außerhalb des Bereichs.

Fehler des Handelsservers

Diese Arten von Fehlern treten in der Phase der Ausführung eines Handels als Struktur einer Handelsanfrage MqlTradeRequest mit der Funktion OrderSend() auf. Wir können diese Fehler auch in der Registerkarte Journal beim Testen oder in der Registerkarte Experte beim Anhängen des Programms an den Chart sehen, der in der aktuellen Zeit ausgeführt wird. Wenn Sie Beispiele für diese Fehler sehen möchten, können Sie dies im Folgenden tun:

Fehlercode	Grund des Fehlers
10006	Anforderung ist abgelehnt
10032	Operation ist nur für reelle Kontos erlaubt.
10033	Limit für Anzahl der schwebenden Aufträgen ist erreicht.
10034	Das Limit des Volumens für Order und Positionen für dieses Symbol ist erreicht
10041	Die Anfrage auf die Aktivierung der Pending Order wurde abgelehnt, die Order wurde abgebrochen.

Sie können alle Codes dieser Art von Fehler finden Sie in der MQL5-Dokumentation über den folgenden Link:

https://www.mql5.com/de/docs/constants/errorswarnings/enum_trade_return_codes

Fehlersuche

In diesem Thema werden wir lernen, wie Debugging durch das MQL5 Debugger-Tool verwendet werden kann. Damit können wir unser erstelltes Programm durch historische oder Live-Daten ausführen, und wir können das tun, indem wir auf die Start-/Fortsetzungs-Debugging auf aktuellen oder historischen Daten klicken, wie in der folgenden Abbildung der Debugger-Schaltflächen aus der Toolbox

1. Starten/Fortsetzen des Debugging mit historischen Kursen

2. Starten/Fortsetzen des Debugging mit aktuellen Kursen

3. Debugging unterbrechen

4. Beenden des Debugging

Sobald wir den Startknopf zum Debuggen mit historischen Daten betätigen, wird das Programm mit historischen Daten ausgeführt, indem einem Chart geöffnet, um das Programm mit den historischen Daten zu debuggen. Wenn wir das Debuggen mit realen Daten wählen, wird das Programm auf dem Chart mit realen Daten gestartet. Neben dem Programm finden Sie das „Debugging“.

Der Strategietester

In diesem Teil oder Thema lernen wir das wichtigste und wertvollste Tool des MetaTrader 5 kennen, den Strategietester mit neuen Funktionen, die besser sind als die des MetaTrader 4, wie zum Beispiel das Testen mehrerer Währungen und andere. Mit welchen Methoden können wir den Strategietester verwenden:

1. Drücken Sie beim Öffnen des MetaTrader 5-Handelsterminals Strg+R auf der Tastatur.

2. Wählen Sie im Menü Ansicht ==> Strategietester.

Danach finden wir den Strategietester wie folgt auf der Registerkarte Übersicht, um zu wählen, was Sie brauchen oder die Art der Prüfung

Auf der Registerkarte „Übersicht“ wählen wir einfach aus, was wir testen wollen, und sobald wir das getan haben, wird die Registerkarte zur Registerkarte „Einstellungen“ mit vordefinierten Einstellungen auf der Grundlage dessen, was Sie zum Testen ausgewählt haben, geändert.

• Einzel (Single): zum Testen von Expert Advisors mit Signalen ohne Visualisierungsmodus.
• Indikator: zum Testen eines Indikators.
• Visualisieren: zum Testen mit Visualisierungsmodus während des Tests auf dem Chart, um zu sehen, wie das Programm auf die Daten basierend auf seinen Anweisungen reagiert.
• Stress und Verzögerungen: wie der Name schon sagt, kann eine Verzögerungen und weitere Belastungen eingestellt werden.
• Optimierungsoptionen (Vollständig, Genetisch, Vorwärts).
• Markt-Scanner: zum Testen des Scannens auf dem Markt.
• Mathematische Berechnungen: auch zum Testen mathematischer Berechnungen.

Sie können auch frühere Testergebnisse sehen, indem Sie die letzte Option Frühere Ergebnisse anzeigen wählen. Sie können auch nach einem bestimmten früheren Test suchen, indem Sie die Suchfunktion unter den Testoptionen verwenden.

Wenn wir zur Registerkarte „Einstellungen“ wechseln, sehen wir Folgendes:

•   1. Expertenprogramm (Expert): Wählen Sie die Programmdatei aus, die Sie testen möchten.
•   2. IDE: zum Öffnen des Quellcodes des ausgewählten Programms.
  
•   3. zum Speichern oder Laden bestimmter Einstellungen.
  
•   4. Symbol: Wählen Sie das zu prüfende Symbol oder die Symbole aus.
  
•   5 . Wählen Sie den Zeitrahmen des ausgewählten Symbols zum Testen.
  
•   6. für die Spezifikationen des ausgewählten Symbols.
  
•   7. Datum: Wählen Sie den Zeitraum aus, der geprüft werden soll.
  
•   8. Wählen Sie den getesteten Startzeitraum.
  
•   9. Wählen Sie die getestete Endperiode.
  
•  10. Vorwärtstest: Auswahl des erforderlichen Anteils des Optimierungszeitraums, der für Vorwärtstests reserviert wird.
  
•  11. wählen Sie das Datum der Weiterleitung aus oder starten Sie es.
  
•  12. und 13. Verzögerungen um zu versuchen, der Realität der Daten und der Ausführungen nahe zu kommen.
  
•  13. um zu versuchen, realen Daten und realen Ausführungen nahe zu kommen.
•  13/2. Modellierung: Wählen Sie das Modell, das Sie testen müssen, nach jedem Tick oder nach etwas anderem aus?
  
•  14. Kreuzen Sie das an, wenn Sie mit Gewinnen in Pips rechnen wollen.
  
•  15. Einlage: Wählen Sie die Höhe der Ersteinzahlung, den Sie benötigen, um mit den Tests zu beginnen.
  
•  16. Wählen Sie die Währung der Einlage.
  
•  17. Wählen Sie den Hebel.
  
•  18. Optimierung: Wählen Sie, ob Sie eine Optimierung wollen oder nicht, werden wir später darauf eingehen.
•  19.Kreuzen Sie das an, wenn Sie beim Test sich den Handel anschauen wollen.

Wir haben auch die Registerkarte Eingaben, um zu prüfen, ob das getestete Programm Eingaben hat, die vom Nutzer eingegeben oder bearbeitet werden können.

Nachdem wir unsere Einstellungen festgelegt und die Start-Taste gedrückt haben, wird das Programm getestet und wir können diesen Test auf dem Chart überwachen, das erscheint, wenn wir den Test visualisieren. In den weiteren Registerkarten sehen Sie die geschlossenen oder stornierten Aufträge, die Historie, die Operationen, um alle Operationen zu sehen, und das Journal, um die ausgedruckten Nachrichten des Programms zu prüfen. Wir können die Leistung des Programms auch über die Registerkarte Graph im Fenster Strategietester überwachen.

Nach Beendigung des Tests können wir auch die Registerkarte „Backtest“ überprüfen, die dann erscheint und alle Teststatistiken und -ergebnisse enthält, wie im folgenden Beispiel:

Je nach Programm, das Sie testen, werden die Daten auf dieser Registerkarte „Backtest“ so oder anders als im vorherigen Beispiel erscheinen.

Es gibt noch eine weitere Sache, die ich hier erwähnen muss, da sie im Testprozess sehr wichtig ist, nämlich die Optimierung, die die Auswahl einer breiten Palette von verschiedenen Parametern und Eingaben und die Überprüfung jeder möglichen Kombination dieser Eingaben oder Parameter umfasst, um zu prüfen und zu testen, welche Parameter die besten Ergebnisse erzielen. Hier wählen wir eines der Optimierungsmodelle auf der Registerkarte Übersicht aus und wählen die passende Einstellung der Optimierung wie in den folgenden Bildern

Die wichtigsten Elemente, die wir nach dem Test überprüfen und bewerten müssen:

• Reingewinn (NetProfit): Dieser wird berechnet, indem der Bruttoverlust vom Bruttogewinn abgezogen wird.
• Inanspruchnahme (draw down): Dies ist der maximale Verlust, den das Konto beim Handel erleidet.
• Gewinn-Faktor (profit factor): Dies ist das Verhältnis von Bruttogewinn zu Bruttoverlust.
• Erwartetes Ergebnis (excepted payoff): Dies ist der durchschnittliche Gewinn oder Verlust einer Handelsposition.
• Erholungsfaktor (recovery factor): Er misst, wie gut sich die getestete Strategie nach Verlusten erholen wird.  

Schlussfolgerung

Wir haben einige wesentliche Themen über eines der wichtigsten und wertvollsten Werkzeuge gelernt, die wir alle beherrschen müssen, wenn wir ein MQL5-Programm entwickeln, nämlich den Testprozess durch den Strategietester des MetaTrader 5-Handelsterminals, und wir haben einige verwandte Themen gelernt, die uns helfen werden, dieses Werkzeug zu verstehen und effektiv zu nutzen. Wir haben gelernt, welche Fehler bei der Entwicklung von MQL5-Programmen auftreten können und welche Arten von Fehlern es gibt:

• Kompilierungsfehler und Warnungen.
• Laufzeitfehler.
• Fehler des Handelsservers.

Dann lernten wir über Debugging, wie man den Debugger der MQL5 IDE nutzt. Wir lernten, wie man den Strategietester des MetaTrader 5 nutzt, indem wir sein unterschiedliches Modell kennenlernten. Wir können Einstellungen des Testens basierend auf dem Modell festlegen, wie wir den Testprozess durch eine andere Registerkarte überwachen können, die alles berichtet, wenn wir ein beliebiges MQL5-Programm testen und wie wir nach dem Testen den Bericht des Tests lesen und die wichtigsten Elemente identifizieren können, die wir überprüfen und bewerten müssen, und wie wir unsere Strategie durch Testen optimieren können, um das beste Ergebnis aus dem Test-MQL5-Programm zu erhalten.

Ich hoffe, dass Sie diesen Artikel und die darin enthaltenen Informationen nützlich finden, um Ihre Ergebnisse durch effektive Tests und die Erstellung Ihrer MQL5-Programme zu verbessern. Wenn Sie den Artikel nützlich finden und Sie mehr Artikel für mich lesen möchten, können Sie meine anderen Artikel lesen, wie z.B. wie wir Handelssysteme auf der Grundlage der beliebtesten technischen Indikatoren erstellen können.