Einführung in MQL5 (Teil 40): Einsteigerleitfaden zur Dateiverarbeitung in MQL5 (II)

Einführung

Willkommen zurück zu Teil 40 der Reihe „Einführung in MQL5“. Im vorherigen Artikel haben wir die Grundlagen für die Dateiverarbeitung in MQL5 gelegt, indem wir gelernt haben, wie man mit „FileSelectDialog“ und „FileOpen“ Dateien erstellt und öffnet. Außerdem haben wir den Aufbau eines einfachen Trading-Journals erstellt und wichtige Kontoinformationen sicher und übersichtlich in einer Datei erfasst. In diesem zweiten Teil werden wir auf dieser Grundlage aufbauen und uns darauf konzentrieren, die tatsächliche Handelshistorie in die Journal-Datei zu exportieren. Sie erfahren, wie Sie auf den Kontoverlauf innerhalb eines bestimmten Zeitraums zugreifen und wichtige Trading-Details wie Ticketnummer, Symbol, Auftragstyp, Losgröße, Eröffnungs- und Schlusszeiten, Kurse, Gewinn und Trading-Ergebnis abrufen können. Diese Datensätze werden dann in einer strukturierten und gut lesbaren Form in das Trading-Journalgeschrieben.

Dieser Artikel richtet sich, genau wie die anderen Artikel dieser Reihe, an Anfänger. Die Gründe für jede Handlung werden akribisch analysiert, und jeder Schritt wird ausführlich beschrieben. Bei der Erweiterung des Skripts für das Trading-Journal werden wir weiterhin dieselbe projektbasierte Methodik anwenden. Am Ende dieses Artikels werden Sie ein praktisches Verständnis dafür haben, wie man Tradeshistorien ausliest und dauerhaft in Dateien speichert. Dies ist für das Trading-Journal, die Analyse, die Berichterstellung und die Strategiebewertung in realen MQL5-Anwendungen von entscheidender Bedeutung.

Spaltenüberschriften für Ihr Trading-Journal erstellen

Im vorherigen Beitrag haben wir gelernt, wie man die Funktion „FileWrite“ in MQL5 verwendet, um Daten in Dateien zu schreiben. Das haben wir als Grundlage genutzt, um Daten aus unseren Programmen in einer Datei zu speichern. In diesem Kapitel werden wir dieses Verständnis vertiefen, indem wir die Kopfzeile des Trading-Journals erstellen. Die Kopfzeile, in der die Spaltenüberschriften angegeben sind, ist die erste Zeile der Datei. Diese Bezeichnungen dienen als Kennzeichnungen für jede einzelne Information, was das spätere Lesen und die Analyse der Handelsdaten erleichtert.

TradeID, Symbol, OrderType, LotSize, OpenTime, OpenPrice, StopLoss, TakeProfit, CloseTime, ClosePrice, Gewinn in Dollar und Ergebnis sind die Spaltenüberschriften für unser Trading-Journal. Jede dieser Kopfzeilen enthält eine wichtige Information zu einem Trade. „OrderType“ gibt an, ob es sich um einen Kauf oder Verkauf handelt, „TradeID“ speichert die Ticketnummer und „Symbol“ bezeichnet das gehandelte Instrument bzw. Währungspaar/Symbol. Während „OpenTime“ und „OpenPrice“ den Zeitpunkt und den Kurs anzeigen, zu dem die Position eröffnet wurde, gibt „LotSize“ das Handelsvolumen an. „CloseTime“ und „ClosePrice“ geben den Zeitpunkt und den Kurs an, zu dem die Position geschlossen wurde, während „StopLoss“ und „TakeProfit“ die für die Position festgelegten Schutzniveaus widerspiegeln. Eine Zusammenfassung des Transaktionsergebnisses ergibt sich aus dem Gewinn in Dollar und dem Ergebnis.

Diese Kopfzeile sollte zuerst geschrieben werden, damit alle nachfolgenden Handelsdaten der richtigen Spalte zugeordnet sind. Das Ergebnis ist ein übersichtliches und professionell gestaltetes Trading-Journal. Jeder Eintrag wird später beim Hinzufügen von Trading-Datensätzen exakt unter der entsprechenden Überschrift ausgerichtet. Anhand der im letzten Artikel behandelten MQL5-Funktionen werden wir in den folgenden Schritten zeigen, wie diese Kopfzeile in die Datei eingefügt wird. Dadurch erhält Ihr Trading-Journal ein übersichtliches Format und lässt sich im Laufe der Zeit problemlos um weitere Daten ergänzen.

Beispiel:

input datetime start_time = D'2026.01.01 00:00:00'; // Show history from this date
input datetime end_time = D'2026.01.31 00:00:00';   // To this date
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   string arrays_filename[];
   string default_filename = "Trading_Journal.csv";

   int result = FileSelectDialog("Select a File", NULL,"CSV files|*.csv", FSD_WRITE_FILE,arrays_filename,default_filename);

   string filename;
   if(result == 0)
     {

      Print("No file selected");

     }

   else
      if(result > 0)
        {

         Print("The trading journal will be saved in ",arrays_filename[0]);

         filename = arrays_filename[0];

        }

      else
        {

         Print(GetLastError());

        }

   int handle = FileOpen(filename, FILE_WRITE|FILE_CSV|FILE_SHARE_READ|FILE_ANSI, ',');


   if(handle == INVALID_HANDLE)
     {

      Print("Error opening file for writing. Error code: ", + GetLastError());

     }

   else
      if(handle != INVALID_HANDLE)
        {

         Print("File Sucessfully Opened");

         string account_name = AccountInfoString(ACCOUNT_NAME);
         double account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
         long account_login = (long)AccountInfoInteger(ACCOUNT_LOGIN);

         FileWrite(handle, "Account Name: " + account_name);
         FileWrite(handle, "Account Balnce: " + DoubleToString(account_balance));
         FileWrite(handle, "Account Login: " + IntegerToString(account_login));
         FileWrite(handle, "Start Time: ", start_time);
         FileWrite(handle, "End Time: ", end_time);
         FileWrite(handle, "Last Update: ", TimeCurrent());

         FileWrite(handle, "\nTradeID","Symbol","OrderType", "LotSize", "OpenTime","OpenPrice","StopLoss", "TakeProfit", "CloseTime", "ClosePrice"
                   ,"Profit($)","Result");

         FileClose(handle);

        }
  }

Ausgabe:

Erläuterung:

Die Kopfzeile des Trading-Journals wird in dieser Codezeile mithilfe der Funktion „FileWrite“ geschrieben. „Handle“, das erste Argument, gibt MQL5 an, in welche Datei geschrieben werden soll. Das Programm wüsste nicht, auf welche Datei es zugreifen soll, wenn das Handle nicht gültig wäre; daher muss es sich um eine zuvor geöffnete oder erstellte Datei handeln. Das erste Zeichen in der Zeile ist „TradeID“, wobei „\n“ für ein Zeilenumbruchzeichen steht. Dadurch wird sichergestellt, dass die Überschrift und der vorangehende Text nicht in derselben Zeile erscheinen. Die Kontodaten und die Tradesaufzeichnungen werden optisch voneinander getrennt, indem stattdessen in eine neue Zeile gewechselt wird.

Die übrigen Werte sind die Spaltenüberschriften des Trading-Journals: Symbol, OrderType, LotSize, OpenTime, OpenPrice, StopLoss, TakeProfit, CloseTime, ClosePrice, Profit($) und Result. Jede dieser Angaben steht für eine Information, die für jede Transaktion dokumentiert wird. Das Programm schreibt jeden dieser Werte in genau der Reihenfolge, in der sie in der Funktion vorkommen, wenn alle diese Werte an die Funktion „FileWrite“ übergeben werden. Alle nachfolgenden Transaktionen erhalten dank dieser Zeile, die zur ersten Zeile des Abschnitts mit den Trading-Daten wird, eine Struktur. Einfach ausgedrückt: Diese Zeile erstellt die erste Zeile der Tabelle innerhalb der Datei. Das Programm und jeder andere, der die Datei liest, können erkennen, welche Art von Daten unter den einzelnen Spaltenüberschriften angezeigt wird. Ohne diese Kopfzeile würde die Datei nur reine Datumsangaben und Zahlen enthalten, was das Lesen und Verstehen erschweren würde.

Analogie:

Die Datei lässt sich mit einem übersichtlichen Notizbuch vergleichen. Um sicherzustellen, dass jeder nachfolgende Eintrag eine klare Bedeutung hat, fügen Sie oben auf der Seite Spaltenüberschriften ein. Beispielsweise könnte die erste Zeile eines Leistungsbogens für Schüler die Spalten „Name des Schülers“, „Naturwissenschaften“, „Mathematik“ und „Englisch“ enthalten. Der Zweck der unter diesen Überschriften aufgeführten Werte ist für jeden, der das Blatt liest, auf den ersten Blick ersichtlich. Ebenso werden in der Zeile, in der „FileWrite“ verwendet wird, die Spaltenüberschriften am Anfang der Datei geschrieben. Der erste Wert, „TradeID“, schreibt die erste Bezeichnung „TradeID“ und beginnt eine neue Zeile. Um die übrigen Spalten zu identifizieren, werden weitere Werte eingegeben, darunter „Symbol“, „OrderType“, „LotSize“, „OpenTime“, „OpenPrice“, „StopLoss“, „TakeProfit“, „CloseTime“, „ClosePrice“, „Profit($)“ und „Result“.

Das Trading-Trading-Journal wird durch diese Kopfzeile strukturiert und übersichtlich gestaltet. Alle nachfolgenden Trades werden in der entsprechenden Spalte angezeigt. Ohne diese Kopfzeile würde die Datei unverarbeitete Datumsangaben und Zahlen enthalten, was das Verständnis erschweren würde. Das Trading-Journal wirkt übersichtlich, gut strukturiert und professionell, wenn die Überschriften zuerst geschrieben werden.

 

Durchlaufen historischer Daten zur Ermittlung der Handelsanzahl

Die Gesamtzahl der Trades innerhalb eines bestimmten Zeitraums ist bei der Arbeit mit mehreren Trades nicht festgelegt. Um die Gesamtzahl der Trades vor deren Verarbeitung zu ermitteln, ist es unerlässlich, die historischen Kontodaten schrittweise durchzugehen. Da wir die Gesamtanzahl kennen, können wir eine Schleife erstellen, die jeden einzelnen Trade sicher und effektiv durchläuft. Auf diese Weise kann der Algorithmus jede Transaktion analysieren, die relevanten Daten extrahieren und feststellen, ob es dem von uns gewünschten Zeitrahmen oder den Anforderungen entspricht. Stellen Sie sich das so vor, als würden Sie ein Notizbuch durchblättern, in dem frühere Transaktionen verzeichnet sind. Zunächst weiß man nicht, wie viele Einträge es insgesamt gibt, aber man kann dies herausfinden und genau die Datensätze extrahieren, die man benötigt, indem man jede Zeile nacheinander durchgeht. Dadurch wird sichergestellt, dass bei der Programmierung nichts ausgelassen und jede Transaktion berücksichtigt wird. Zudem wird dadurch die Möglichkeit von Fehlern ausgeschlossen, die entstehen könnten, wenn wir unter der Annahme einer festgelegten Anzahl von Trades versuchen, auf einen Trade zuzugreifen, der gar nicht existiert.

Um ein zuverlässiges Trading-Journal zu führen, muss man zunächst die Anzahl der Trades kennen. Sobald die Gesamtzahl der Trades feststeht, lässt sich eine Schleife erstellen, die jeden Trade einzeln verarbeitet und dabei Informationen wie Ticketnummer, Symbol, Auftragstyp, Losgröße, Eröffnungs- und Schlusszeiten, Kurse, Gewinn und Ergebnis erfasst. Diese Methode stellt sicher, dass das Trading-Journal alle relevanten Transaktionen für den festgelegten Zeitraum enthält und dass es korrekt und vollständig ist.

Beispiel:

FileWrite(handle, "Account Name: " + account_name);
FileWrite(handle, "Account Balnce: " + DoubleToString(account_balance));
FileWrite(handle, "Account Login: " + IntegerToString(account_login));
FileWrite(handle, "Start Time: ", start_time);
FileWrite(handle, "End Time: ", end_time);
FileWrite(handle, "Last Update: ", TimeCurrent());


FileWrite(handle, "\nTradeID","Symbol","OrderType", "LotSize", "OpenTime","OpenPrice","StopLoss", "TakeProfit", "CloseTime", "ClosePrice"
          ,"Profit($)","Result");

bool success = HistorySelect(start_time, end_time);

//Total Deals
int totalDeal = 0;
if(success)
  {
   for(int i = 0; i < HistoryDealsTotal(); i++)
     {
      ulong ticket = HistoryDealGetTicket(i);
      if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_IN)
        {
         totalDeal++;

        }

     }
  }

FileClose(handle);

Erläuterung:

Das Programm beginnt mit einer Auswahl historischer Transaktionen, die in einem bestimmten Zeitraum stattgefunden haben. Durch die Übergabe einer Start- und einer Endzeit wählt die Funktion „HistorySelect()“ alle Trades im Kontoverlauf so aus, dass nur diejenigen berücksichtigt werden, die innerhalb dieses Zeitraums stattgefunden haben. Um dem Programm mitzuteilen, ob die Auswahl erfolgreich war, wird das Ergebnis in einer booleschen Variablen namens „success“ gespeichert. Das Ergebnis „true“ bedeutet, dass Transaktionen zur Verarbeitung bereitstehen; ein Ergebnis „false“ bedeutet, dass in diesem Zeitraum entweder keine Trades stattgefunden haben oder dass ein Fehler aufgetreten ist. Auf diese Weise wird sichergestellt, dass das Programm ausschließlich mit gültigen historischen Daten arbeitet.

Anschließend wird vom Programm eine Variable initialisiert, um die Gesamtzahl der Trades zu erfassen. Zunächst ist der Wert auf Null gesetzt. Anschließend wird im Programm eine if-Anweisung verwendet, um festzustellen, ob die Auswahl aus dem Verlauf erfolgreich war. Das Programm durchläuft jeden Trade, sofern die Auswahl erfolgreich war; andernfalls überspringt es diesen Schritt. Dadurch wird verhindert, dass das Programm versucht, auf nicht vorhandene Trades zuzugreifen. Der nächste Schritt besteht darin, alle Trades in den ausgewählten historischen Daten durchzugehen. Ausgehend vom Index 0 wird der Vorgang so lange wiederholt, bis die durch HistoryDealsTotal() angegebene Anzahl von Transaktionen erreicht ist. Das Programm kann jeden Trade separat verarbeiten, da jede Iteration einen einzelnen Trade darstellt. Dadurch stellt das Programm sicher, dass keine Transaktion innerhalb des angegebenen Zeitraums übersehen wird.

Das Programm ruft über die Funktion „HistoryDealGetTicket(i)“ innerhalb der Schleife die eindeutige Ticketnummer der aktuellen Trades ab. Jeder Trade in MetaTrader 5 hat eine Ticketnummer, die als Kennung dient. Ähnlich wie bei der Verwendung einer Seriennummer zum Auffinden eines bestimmten Datensatzes in einem Ablagesystem ermöglicht dieses Ticket dem Computer, die Informationen zu diesem Trade genau zu identifizieren und abzurufen. Mit der Funktion „HistoryDealGetInteger(ticket, DEAL_ENTRY)“ ermittelt das Programm anschließend die Art des Trades. Trades, bei denen Positionen eröffnet werden, werden mithilfe der Konstante DEAL_ENTRY_IN als Eröffnungstransaktionen gekennzeichnet. Da wir andere Transaktionsarten wie den Abschluss von Trades oder Korrekturen, die möglicherweise im Kontoverlauf enthalten sind, nicht berücksichtigen möchten, ist dieser Schritt von entscheidender Bedeutung. Um sicherzustellen, dass nur Trades, die tatsächlich eine Position eröffnet haben, in die Gesamtsumme einfließen, vergleicht der Computer die Transaktionsart mit DEAL_ENTRY_IN.

Schließlich erhöht das Programm die Gesamtzahl der Transaktionen jedes Mal um eins, wenn die Bedingung erfüllt ist. Die Gesamtzahl der Eröffnungstransaktionen während des festgelegten Zeitraums wird am Ende der Schleife in der Variablen „totalDeal“ gespeichert. Die nachfolgenden Schritte, wie beispielsweise die Erfassung der Trades in einem Trading-Journal oder die erneute Durchsicht, um detaillierte Informationen zu jedem Trade zu sammeln, hängen von dieser Gesamtsumme ab. Bei der Verarbeitung historischer Daten gewährleistet das Programm Genauigkeit und vermeidet Fehler, indem es zunächst die Trades zählt.

Analogie:

Jede Schachtel symbolisiert einen Trade, der jemals auf dem Konto stattgefunden hat; stellen Sie sich Ihre Tradeshistorie als einen großen Archivraum vor, der voller Kartons mit Dokumenten ist. Als Erstes wählt das Programm die zu untersuchenden Kartons aus. Die Funktion „HistorySelect()“ funktioniert hier wie ein Assistent: „Zeige mir nur die Kartons, die zwischen Januar und März datiert sind“ – so funktioniert die Auswahlfunktion. Entweder kommt der Assistent mit leeren Händen zurück oder mit den richtigen Kartons. Die Erfolgsvariable, die lediglich angibt, ob der Assistent etwas Verwertbares gefunden hat, speichert das Ergebnis. Wenn die Auswahl erfolgreich war, stehen die Kartons auf dem Tisch. Das Programm weiß, dass es nicht blindlings fortfahren darf, wenn die Aussage falsch ist, da es dann nichts zu prüfen gibt.

Als Nächstes richtet das Programm einen Zähler ein – das ist so, als würde man ein Notizbuch herausholen und ganz oben eine Null eintragen, bevor man mit dem Zählen beginnt. Die Anzahl der gültigen Transaktionen wird von diesem Zähler erfasst. Anschließend prüft das Programm, ob die Kartons tatsächlich zurückgegeben wurden, bevor die Zählung beginnt. Das Programm vermeidet Leerzeichen und Fehler, falls keine Kartons zurückgegeben wurden, da es dann nichts zu zählen gäbe. Das Programm beginnt damit, jeden Karton einzeln zu prüfen, nachdem überprüft wurde, dass sie verfügbar sind. Es beginnt mit dem ersten Karton und läuft so lange weiter, bis der letzte Karton für diesen Zeitraum zurückgegeben wird. Das ist vergleichbar damit, vor einem Tisch zu stehen und jedes Dokument einzeln durchzugehen, um sicherzustellen, dass keines übersehen wird. Jeder Schritt der Schleife symbolisiert das Aufnehmen von und das Hineinschauen in einen Karton.

Das Programm überprüft das Etikett jeder Kiste, auf dem die Ticketnummer vermerkt ist. Dieses Ticket funktioniert ähnlich wie ein Seriencode oder eine Dateinummer, die auf dem Ordner vermerkt ist. Dadurch erhält der Trade eine eindeutige Identifikation, und das Programm kann die relevanten Informationen extrahieren, ohne sie mit einer anderen Transaktion zu verwechseln. Das Programm ermittelt die Art des Dokuments, nachdem es den Tradesvorgang identifiziert hat. Während einige Dokumente die Eröffnung eines Trades dokumentieren, zeigen andere die Schließung oder Anpassung eines Trades. „Bezieht sich dieses Dokument auf die Eröffnung eines Trades?“ – dieser Frage entspricht die Prüfung DEAL_ENTRY_IN. Es zählen nur die Dokumente, bei denen die Antwort „Ja“ lautet. Dokumente, die andere Dinge darstellen, werden nicht berücksichtigt.

Das Programm fügt dem Zähler jedes Mal ein Dokument hinzu, wenn es eines findet, das den Beginn eines Trades symbolisiert. Der Zähler zeigt die Gesamtzahl der im ausgewählten Zeitraum eröffneten Transaktionen an, sobald alle Kartons geprüft wurden. Diese letzte Zahl ist von entscheidender Bedeutung, da sie dem Programm angibt, wie viele Trades es als Nächstes verarbeiten muss – sei es, um spezifischere Daten zu extrahieren oder um diese in einem Trading-Journal zu erfassen. Das Zählen hilft zunächst dabei, Ordnung zu halten und spätere Fehler zu vermeiden.

 

Ausfüllen der Spalte „Trade-ID“ in der Datei mithilfe des Handelsverlaufs

Nachdem wir nun wissen, wie wir die Gesamtzahl der innerhalb eines bestimmten Zeitraums getätigten Trades ermitteln können, besteht der nächste Schritt darin, diese Transaktionen durchzugehen und die einzelnen Ticketnummern zu extrahieren. Diese Ticketnummern, die in die Spalte „Trade-ID“ der Datei eingetragen werden, dienen als eindeutige Kennungen für jeden Handel. Wir beginnen mit dem ersten Trade in dem ausgewählten Zeitraum und gehen Schritt für Schritt vor, bis wir den letzten Trade erreichen, da die Trades in chronologischer Reihenfolge erfasst werden. Im Laufe dieses Vorgangs wird jeweils eine Ticketnummer abgerufen und steht bereit, in die Datei geschrieben zu werden.

Dadurch wird sichergestellt, dass jede Transaktion ordnungsgemäß erfasst und der entsprechenden Zeile im Trading-Journal zugeordnet wird. Indem wir die Ticketnummern nacheinander extrahieren, stellen wir eine klare und strukturierte Verknüpfung zwischen dem Transaktionsverlauf und den Dateidaten sicher. Diese Methode gewährleistet die Genauigkeit und Übersichtlichkeit des Journals und erleichtert gleichzeitig die nachträgliche Eingabe weiterer Transaktionsdetails wie Symbol, Auftragstyp, Kurse und Gewinn.

Die Ticketnummer für jeden Trade wird in einem dynamischen Array vom Typ „ulong“ gespeichert, das wir zunächst deklarieren werden. Dieses Array bietet uns eine übersichtliche Methode, alle Trade-IDs zu erfassen und zu verarbeiten, bevor wir sie in die Datei eintragen, da jeder Trade in MetaTrader 5 eine eindeutige Ticket-ID hat.

Beispiel:

//Trade ID
ulong trade_id[];
ArrayResize(trade_id,totalDeal);
int j = 0;

if(success)
  {
   for(int i = 0; i < HistoryDealsTotal(); i++)
     {
      ulong ticket = HistoryDealGetTicket(i);


      if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_IN)
        {
         trade_id[j] = ticket;

         j++; // Increment the array index for the next valid ticket

        }
     }
  }

for(int i = 0; i < totalDeal; i++)
  {
   FileWrite(handle, trade_id[i]);
  }


FileClose(handle);

Ausgabe:

Erläuterung:

„ulong trade_id[]“ wird zunächst als dynamisches Array deklariert, um die Ticketnummern der Trades zu speichern. Aufgrund seines dynamischen Charakters ist seine Größe zum Zeitpunkt der Deklaration noch nicht festgelegt. Das ist hilfreich, wenn bis zur Laufzeit nicht bekannt ist, wie viele Trades stattfinden werden. Ungeachtet dieser Flexibilität muss das Array dennoch eine bestimmte Größe haben, bevor Werte hinzugefügt werden können. MetaTrader zeigt einen Fehler „Array außerhalb des zulässigen Bereichs“ an, wenn das Programm versucht, das Array zu füllen, ohne ihm zuvor eine passende Größe zuzuweisen, da es sonst auf Speicherplatz zugreifen würde, der noch nicht zugewiesen wurde.

Aus diesem Grund ist der Aufruf von ArrayResize(trade_id, totalDeal); erforderlich. Um sicherzustellen, dass jede Ticketnummer sicher gespeichert wird, passt das Programm die Größe des Arrays an die Gesamtzahl der zuvor gezählten Transaktionen an. Einfach ausgedrückt lässt sich das Array mit einem leeren Regal vergleichen. Das Regal wird durch eine Deklaration erstellt, die Anzahl der Fächer wird jedoch durch die Anpassung seiner Größe festgelegt. Reichen die Plätze nicht aus, würde beim Versuch, Waren darauf abzustellen, ein Fehler auftreten.

Jede Ticketnummer wird im Array gespeichert, während der Computer die Tradeshistorie durchläuft und gültige Eröffnungstrades ermittelt. Um sicherzustellen, dass nur Trades erfasst werden, die offene Positionen betreffen, erfolgt dies innerhalb der Bedingung, die nach DEAL_ENTRY_IN sucht. Hier spielt die Variable j eine wichtige Rolle. Auch wenn die Schleifenvariable i alle vergangenen Trades durchläuft, gelten nicht alle davon als Eröffnungs-Trades. Erst wenn ein gültiger Trade erkannt wird, wird die Variable j als eigenständiger Index fortgeführt. Dadurch wird sichergestellt, dass Tickets beim fortlaufenden Speichern nicht überschrieben werden oder Lücken im Array entstehen. j wird jedes Mal erhöht, wenn ein gültiges Ticket zum Array hinzugefügt wird. Durch das Vorrücken der Speicherposition wird die nächste qualifizierte Ticketnummer im nächsten verfügbaren Array-Platz platziert. Ohne j würde das Programm entweder die Daten falsch zuordnen oder frühere Ticketnummern überschreiben, was zu ungenauen oder fehlenden Journalbuchungen führen würde.

Das Programm nutzt die bekannte Anzahl der Trades, um das Array durchzugehen, nachdem alle Ticketnummern der Trades gesammelt und dort gespeichert wurden. Mit FileWrite(handle, trade_id[i]); wird während dieser Schleife jedes Ticket in die Datei geschrieben. Bei diesem Vorgang wird jede Ticketnummer automatisch nacheinander in die Spalte „Trade-ID“ der Datei eingefügt, da das Array die richtige Größe hatte und der Reihe nach gefüllt wurde. Dadurch wird sichergestellt, dass alle Trade-IDs übersichtlich, strukturiert und zuverlässig in das Trading-Journal eingetragen werden.

Analogie:

Stellen Sie sich das dynamische Array als ein leeres Notizbuch vor, in das Sie die Ticketnummern der Trades eintragen möchten. Das erstmalige Deklarieren des Arrays ist vergleichbar mit dem Anlegen eines neuen Notizbuchs, ohne festzulegen, wie viele Seiten es enthalten soll. Obwohl Sie sicher sind, dass Sie Ticketnummern eintragen würden, sind Sie sich nicht sicher, wie viele Trades Sie finden werden. Das Array ist aufgrund seiner Anpassungsfähigkeit dynamisch. Sie müssen jedoch vor Beginn des Schreibens festlegen, wie viele Seiten das Notizbuch umfassen soll. Wenn du mit dem Schreiben beginnst, ohne genügend Seiten freizulassen, wird dir der Platz ausgehen und es entstehen Probleme. Genau aus diesem Grund muss die Größe des Arrays angepasst werden. Sie geben dem Notizbuch vor, wie viele Seiten es vorbereiten soll, indem Sie die Gesamtzahl der Transaktionen aus der vorherigen Zählung verwenden. Dadurch werden Fehler vermieden, die auftreten könnten, wenn Sie versuchen würden, mehr als den vorgesehenen Platz zu belegen.

Bei der Durchsicht der Tradeshistorie stößt der Computer auf zahlreiche Dokumente; nicht alle davon sind hilfreich. Während einige Datensätze Schließungen oder Änderungen ausweisen, weisen andere die Eröffnung von Trades aus. Die Ticketnummer wird jedes Mal auf die folgende leere Seite im Notizbuch eingetragen, wenn das Programm eine gültige Eröffnungstransaktion erkennt. Die Variable j dient als Seitenmarkierung. Es wird die nächste verfügbare Seite vermerkt, auf der ein gültiges Ticket ausgestellt werden sollte. Ohne diese Markierung würde das Notizbuch unübersichtlich und unzuverlässig werden, da das Programm frühere Einträge überschreiben oder dazwischen leere Seiten einfügen könnte.

Nachdem alle gültigen Ticketnummern eingegeben wurden, liest das Programm das Notizbuch von der ersten bis zur letzten Seite durch. Zeile für Zeile wird dann jede Ticketnummer in die Spalte „Trade-ID“ der Datei eingetragen. So entsteht in der Datei eine vollständige und übersichtliche Liste der Trade-IDs, da das Notizbuch mit der entsprechenden Seitenanzahl angelegt und in der richtigen Reihenfolge ausgefüllt wurde. Dadurch ist das Trading-Journal korrekt, übersichtlich und für die nachfolgenden Schritte vorbereitet, in denen weitere Trading-Details hinzugefügt werden.

 

Ausfüllen der Spalten „Symbol“ und „OrderType“ in der Datei

Die Felder „Symbol“ und „Auftragstyp“ müssen ausgefüllt werden, nachdem die Trade-ID-Werte korrekt in die Datei geschrieben wurden. Da sie Aufschluss darüber geben, was gehandelt und wie der Trade abgewickelt wurde, sind diese beiden Informationen von entscheidender Bedeutung. Das Symbol gibt den betreffenden Markt an, der Auftragstyp gibt an, ob es sich um eine Kauf- oder Verkaufsorder handelte, und die Trade-ID dient zur eindeutigen Identifizierung einer Transaktion. Wir verwenden hierfür dieselben historischen Trading-Daten, die zuvor dafür ausgewählt wurden. Jede Ticketnummer liegt uns bereits vor; daher können wir sie nutzen, um weitere Informationen zu dieser konkreten Transaktion zu erhalten. Wir können feststellen, ob der Trade auf EURUSD, GBPUSD oder einem anderen Markt stattfand, der über das Konto zugänglich ist, da das Symbol direkt aus dem Trading-Journal übernommen wird.

Der Auftragstyp gibt die Richtung des Handels an und legt fest, ob es sich um einen Kauf oder einen Verkauf handelte. Diese Unterscheidung liefert wertvolle Informationen bei der Auswertung von Handelsdaten. Es ermöglicht Händlern, die relative Performance von Long- und Short-Positionen zu bewerten, deren marktbezogene Verhaltensmuster zu verstehen und ihre Handelsstrategie insgesamt zu verbessern.

Beispiel:

ulong trade_id[];
ArrayResize(trade_id,totalDeal);

string symbol[];
string order_type[];
ArrayResize(symbol,totalDeal);
ArrayResize(order_type,totalDeal);
int j = 0;

if(success)
  {
   for(int i = 0; i < HistoryDealsTotal(); i++)
     {
      ulong ticket = HistoryDealGetTicket(i);


      if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_IN)
        {
         trade_id[j] = ticket;

         symbol[j] =  HistoryDealGetString(ticket, DEAL_SYMBOL);

         if(HistoryDealGetInteger(ticket,DEAL_TYPE) == DEAL_TYPE_BUY)
           {
            order_type[j] = "BUY";
           }

         if(HistoryDealGetInteger(ticket,DEAL_TYPE) == DEAL_TYPE_SELL)
           {
            order_type[j] = "SELL";
           }

         j++; // Increment the array index for the next valid ticket

        }
     }
  }

for(int i = 0; i < totalDeal; i++)
  {
   FileWrite(handle, trade_id[i],symbol[i],order_type[i]);
  }
FileClose(handle);

Ausgabe:

Erläuterung:

Zu Beginn der Prozedur werden zwei dynamische Zeichenfolgen-Arrays deklariert, um Informationen zum Auftragstyp und die Symbolnamen zu speichern. Da die Anzahl der Trades je nach ausgewähltem historischen Datensatz schwankt, haben diese Arrays zunächst keine festgelegte Größe. Die Arrays werden entsprechend der Gesamtzahl der Transaktionen vergrößert, sobald diese feststeht. Das Programm stellt sicher, dass das Symbol und der Auftragstyp jedes Trades korrekt erfasst werden, indem es mithilfe von ArrayResize die erforderliche Speichermenge zuweist und so Fehler aufgrund von Array-Grenzen ausschließt.

Das Programm ruft das Symbol für jeden Trade ab, sobald die Arrays bereit sind. Hierfür wird die Funktion „HistoryDealGetString“ mit dem Attribut „DEAL_SYMBOL“ verwendet. Es wird eine String-basierte Funktion benötigt, da das Symbol, wie beispielsweise EURUSD oder GBPUSD, als Text gespeichert ist. Das Programm kann mithilfe von „HistoryDealGetString“ lesbaren Text direkt aus dem Transaktionsdatensatz extrahieren. Um die Übereinstimmung mit der Trade-ID und anderen Transaktionsdetails zu gewährleisten, wird das abgerufene Symbol anschließend an der entsprechenden Position im Array gespeichert.

Der Auftragstyp für jeden Trade wird dann vom Computer festgelegt. Die Trade-Richtung wird durch eine Ganzzahl dargestellt, die intern gespeichert wird. Das Programm kann mithilfe der Funktion „HistoryDealGetInteger“ und des Feldes „DEAL_TYPE“ feststellen, ob es sich bei der Transaktion um einen Kauf oder einen Verkauf handelte. Dieser interne Wert wird dann mithilfe einer Bedingung in ein für Menschen lesbares Format umgewandelt. Das Programm fügt den Text „BUY“ zum Array „order_type“ hinzu, wenn der Tradestyp mit „DEAL_TYPE_BUY“ übereinstimmt. Das Programm weist den Text „SELL“ zu, wenn die Bedingung DEAL_TYPE_SELL erfüllt ist.

Da es sich bei den von der Plattform zurückgegebenen Rohwerten um interne Konstanten handelt, die eher der Programmlogik als der Darstellung dienen, sind diese Anforderungen von entscheidender Bedeutung. Werte wie DEAL_TYPE_BUY oder DEAL_TYPE_SELL, die nicht benutzerfreundlich sind und in einem Trading-Journal nicht übersichtlich dargestellt werden, könnten in die in die Datei geschriebene Ausgabe aufgenommen werden, wenn die Bedingungen nicht angewendet würden. Diese internen Konstanten werden in leicht verständliche Textbezeichnungen umgewandelt, was die Lesbarkeit, die Professionalität und den analytischen Nutzen der Datei verbessert.

Erfassung der Eröffnungsdaten eines Trades

Nachdem die Trade-ID, das Symbol und der Auftragstyp eingetragen wurden, müssen die Details des Trades in die Datei eingegeben werden. Stop-Loss, Take-Profit, Eröffnungszeit, Eröffnungskurs und Losgröße sind einige dieser Einzelheiten. Die Erfassung dieser Daten ist von entscheidender Bedeutung, da sie einen umfassenden Überblick über die Ausführung jedes einzelnen Trades bieten, einschließlich der Positionsgröße, des Zeitpunkts, der Kursniveaus und der Risikomanagement-Einstellungen. Diese Daten können wir für jede einzelne Ticketnummer direkt aus dem Kontoverlauf abrufen, der im Array gespeichert ist. Während „Open Time“ und „Open Price“ den Zeitpunkt und den Kurs angeben, zu dem die Position eröffnet wurde, gibt die „Lot Size“ den Umfang der Position an. Die zur Steuerung des Risikos und des potenziellen Gewinns festgelegten Werte werden durch Stop-Loss und Take-Profit angegeben. Indem Sie diese Zahlen eintragen, können Sie sicherstellen, dass das Trading-Journal alle wichtigen Details zu jeder Transaktion enthält.

Beispiel:

ulong trade_id[];
ArrayResize(trade_id,totalDeal);

string symbol[];
string order_type[];
ArrayResize(symbol,totalDeal);
ArrayResize(order_type,totalDeal);

double lot_size[];
datetime open_time[];
double open_price[];
double stop_l[];
double take_p[];

ArrayResize(lot_size,totalDeal);
ArrayResize(open_time,totalDeal);
ArrayResize(open_price,totalDeal);
ArrayResize(stop_l,totalDeal);
ArrayResize(take_p,totalDeal);

int j = 0;

if(success)
  {
   for(int i = 0; i < HistoryDealsTotal(); i++)
     {
      ulong ticket = HistoryDealGetTicket(i);


      if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_IN)
        {
         trade_id[j] = ticket;

         symbol[j] =  HistoryDealGetString(ticket, DEAL_SYMBOL);

         if(HistoryDealGetInteger(ticket,DEAL_TYPE) == DEAL_TYPE_BUY)
           {
            order_type[j] = "BUY";
           }

         if(HistoryDealGetInteger(ticket,DEAL_TYPE) == DEAL_TYPE_SELL)
           {
            order_type[j] = "SELL";
           }

         lot_size[j] = HistoryDealGetDouble(ticket,DEAL_VOLUME);
         open_time[j] = (datetime)HistoryDealGetInteger(ticket,DEAL_TIME);
         open_price[j]  = HistoryDealGetDouble(ticket,DEAL_PRICE);
         stop_l[j] = HistoryDealGetDouble(ticket,DEAL_SL);
         take_p[j] = HistoryDealGetDouble(ticket,DEAL_TP);

         j++; // Increment the array index for the next valid ticket

        }
     }
  }

for(int i = 0; i < totalDeal; i++)
  {
   FileWrite(handle, trade_id[i],symbol[i],order_type[i],lot_size[i],open_time[i],open_price[i],stop_l[i],take_p[i]);
  }

FileClose(handle);

Ausgabe:

Erläuterung:

Für die Parameter „Tradesgröße“, „Eröffnungszeit“, „Eröffnungskurs“, „Stop-Loss“ und „Take-Profit“ erstellen wir separate dynamische Arrays, um die Trading-Daten entsprechend zu ordnen. Jedes Array hat einen Datentyp, der dem Typ der darin enthaltenen Daten entspricht. Da Dezimalgenauigkeit erforderlich ist, werden Preis- und Loswerte als „double“ deklariert, während „Open Time“ zeitbezogene Daten mithilfe des Datentyps „datetime“ präzise wiedergibt. Auch wenn die genaue Anzahl im Voraus nicht bekannt ist, kann das Programm eine beliebige Anzahl von Trades innerhalb des gewählten Zeitraums verarbeiten, sofern diese Arrays dynamisch deklariert werden.

Wir müssen dennoch Speicherplatz für diese Arrays reservieren, auch wenn sie dynamisch sind, um Probleme zu vermeiden. Für jedes Array verwenden wir ArrayResize und legen dessen Größe auf totalDeal fest, also die Anzahl der zuvor gezählten Trades. Durch die Größenanpassung wird sichergestellt, dass genügend Speicherplatz für die Speicherung eines Werts für jede Transaktion vorhanden ist. Ohne diesen Schritt würde das Programm versuchen, in einen Speicherbereich zu schreiben, der noch nicht zugewiesen wurde, was beim Versuch, die Daten eines Trades zu speichern, zu einem Fehler „Array außerhalb des zulässigen Bereichs“ führen würde. Wenn Sie beispielsweise ein Array deklarieren, erhalten Sie leere Kartons, aber wenn Sie die Größe des Arrays ändern, weiß das Programm, wie viele Kartons Sie tatsächlich benötigen. Das Programm ruft die entsprechenden Trading-Daten für jede gültige Ticketnummer ab, sobald die Arrays vorbereitet sind.

Mit der Funktion HistoryDealGetDouble(ticket, DEAL_VOLUME) wird die Losgröße einer Transaktion ermittelt und im Array „lot_size“ gespeichert. Mit „HistoryDealGetInteger(ticket, DEAL_TIME)“ wird die Eröffnungszeit abgerufen, die anschließend in den Datentyp „datetime“ umgewandelt und im Array „open_time“ gespeichert wird. Mit „HistoryDealGetDouble(ticket, DEAL_PRICE)“ wird der Eröffnungskurs abgerufen. Mit „HistoryDealGetDouble(ticket, DEAL_SL)“ wird der Stop-Loss abgerufen, und mit „HistoryDealGetDouble(ticket, DEAL_TP)“ wird der Take-Profit abgerufen. Um sicherzustellen, dass alle Daten zur Trade-Eröffnung mit der entsprechenden Ticketnummer übereinstimmen, wird jeder dieser Werte am aktuellen Index j des zugehörigen Arrays gespeichert. 

Bevor die numerischen Einstiegsdaten in die Datei geschrieben werden, kann das Programm sie mithilfe dieser Arrays im Arbeitsspeicher speichern. Indem wir zunächst die Daten erfassen, können wir jeden Trade systematisch durchgehen und die Informationen in die entsprechenden Abschnitte des Trading-Journals eintragen. Diese Methode gewährleistet, dass für jeden Trade alle Eröffnungsdaten präzise und in der richtigen Reihenfolge vorliegen, wobei die Struktur der Datei erhalten bleibt.

 

Die Datei mit Daten zur Positionsschließung füllen

Es ist sinnvoll, die Informationen zu den Schließungsdaten eines Trades erst nach der Erfassung der Eröffnungsdaten anzugeben. Um sicherzustellen, dass jeder Trading-Datensatz vollständig ist, werden Gewinn, Ergebnis, Schlusszeit und Schlusskurs hinzugefügt. Diese Angaben zeigen das Endergebnis des Trades und liefern die für die Leistungsbewertung erforderlichen Informationen. Durch die Erfassung sowohl der Eröffnungs- als auch der Schließungsdaten können Trader die Konsistenz ihrer Strategien bewerten, deren Vor- und Nachteile genau ermitteln und das Kontowachstum präzise nachverfolgen.

Das Programm kann die Schließungsdaten direkt aus dem Kontoverlauf abrufen, indem es die im Array gespeicherten Ticketnummern der Trades verwendet. Der „Close Price“ gibt den Kurs an, zu dem die Position geschlossen wurde, während die „Close Time“ den genauen Zeitpunkt angibt, zu dem der Trade beendet wurde. Der Gewinn bestimmt das finanzielle Ergebnis des Trades, während die Spalte „Ergebnis“ angibt, ob der Trade gewinnbringend, erfolglos oder ausgeglichen war. Durch das Erfassen und Dokumentieren dieser Zahlen ist das Trading-Journal vollständig und für die Analyse vorbereitet, da für jeden Trade sowohl Eröffnungs- als auch Schließungsdaten vorliegen.

Beispiel:

datetime close_time[];
double close_price[];
double profit[];
string result[];

ArrayResize(close_time,totalDeal);
ArrayResize(close_price,totalDeal);
ArrayResize(profit,totalDeal);
ArrayResize(result,totalDeal);

int j = 0;
int h = 0;

if(success)
  {
   for(int i = 0; i < HistoryDealsTotal(); i++)
     {
      ulong ticket = HistoryDealGetTicket(i);

      if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_IN)
        {
         trade_id[j] = ticket;

         symbol[j] =  HistoryDealGetString(ticket, DEAL_SYMBOL);

         if(HistoryDealGetInteger(ticket,DEAL_TYPE) == DEAL_TYPE_BUY)
           {
            order_type[j] = "BUY";
           }

         if(HistoryDealGetInteger(ticket,DEAL_TYPE) == DEAL_TYPE_SELL)
           {
            order_type[j] = "SELL";
           }

         lot_size[j] = HistoryDealGetDouble(ticket,DEAL_VOLUME);
         open_time[j] = (datetime)HistoryDealGetInteger(ticket,DEAL_TIME);
         open_price[j]  = HistoryDealGetDouble(ticket,DEAL_PRICE);
         stop_l[j] = HistoryDealGetDouble(ticket,DEAL_SL);
         take_p[j] = HistoryDealGetDouble(ticket,DEAL_TP);

         j++; // Increment the array index for the next valid ticket

        }

      if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_OUT)
        {
         trade_id[h] = ticket;
         close_time[h] = (datetime)HistoryDealGetInteger(ticket,DEAL_TIME);
         close_price[h]  = HistoryDealGetDouble(ticket,DEAL_PRICE);
         profit[h] = HistoryDealGetDouble(ticket,DEAL_PROFIT);

         if(profit[h] > 0)
           {

            result[h] = "WIN";

           }
         else
            if(profit[h] < 0)
              {

               result[h] = "LOSS";

              }
            else
              {

               result[h] = "Break Even";

              }

         h++;
        }
     }
  }

for(int i = 0; i < totalDeal; i++)
  {
   FileWrite(handle, trade_id[i],symbol[i],order_type[i],lot_size[i],open_time[i],open_price[i],stop_l[i],take_p[i],close_time[i],close_price[i],profit[i]
             ,result[i]);
  }
FileClose(handle);

Ausgabe:

Erläuterung:

Zunächst erstellen wir dynamische Arrays für die vier Schließungsdatenpunkte, die wir erfassen möchten: Ergebnis, Gewinn, Schlusszeit und Schlusskurs. Die „Close Time“ wird als Datums- und Zeitangabe erfasst, da sie den genauen Zeitpunkt des Tradesabschlusses angibt. Da es sich bei Gewinn und Schlusskurs um Zahlen handelt, wird der Typ „double“ verwendet, und das Ergebnis wird als Zeichenfolge gespeichert, die zur Darstellung von Textergebnissen wie „GEWINN“, „VERLUST“ oder „Break-Even“ verwendet werden kann. Diese Arrays werden dynamisch deklariert, da wir die Anzahl der Trades im Voraus nicht kennen.

Wir verwenden ArrayResize, um für jedes Array Speicherplatz in der Größe „totalDeal“ zuzuweisen – ein Wert, der zuvor bei der Zählung der Transaktionen ermittelt wurde –, um die Daten für jede Transaktion sicher zu speichern. Durch die Größenanpassung lassen sich Probleme vermeiden, die auftreten könnten, wenn wir versuchen würden, außerhalb der Array-Grenzen zu schreiben, und es wird sichergestellt, dass für die Schließungsinformationen jedes Trades ausreichend Platz vorhanden ist. Stellen Sie sich das so vor, als würden Sie eine Reihe von beschrifteten Kartons einrichten, in denen die Schließungsinformationen für jeden Trade gespeichert werden.

Danach wird die Variable h auf Null gesetzt. Die Schließungsdaten werden in den Arrays gespeichert, wobei diese Variable als Indexmarkierung dient. Wir erhöhen h, um zum nächsten verfügbaren Platz zu gelangen, nachdem wir die Daten jedes Trades, das einen Abschluss anzeigt, an der aktuellen h-Indexposition in den Arrays gespeichert haben. Da nicht alle Trades im History-Array mit den Trades mit Positionsschließung übereinstimmen, ist dies von entscheidender Bedeutung. Wir haben bereits mehrere Transaktionen abgeschlossen, bei denen es sich um Eröffnungstransaktionen handelt. Die Arrays für die Schließungsdaten können Lücken aufweisen oder frühere Daten überschreiben, wenn kein eindeutiger Index h vorhanden ist. 

Nur Trades, die mit „DEAL_ENTRY_OUT“ gekennzeichnet sind, werden vom Programm verarbeitet, nachdem es mit der Funktion „HistoryDealGetInteger(ticket, DEAL_ENTRY)“ die Art der jeweiligen Transaktion überprüft hat. Die Eröffnungs-Arrays enthalten bereits die Eröffnungstransaktionen, die mit DEAL_ENTRY_IN gekennzeichnet sind. Durch diese Unterscheidung werden die Genauigkeit und die Struktur der Transaktionsaufzeichnung gewahrt, wodurch sichergestellt wird, dass in dieser Phase ausschließlich Schließungs-Trades bearbeitet werden.

Mit der Funktion „HistoryDealGetInteger(ticket, DEAL_TIME)“ ermittelt das Programm den Schlusszeitpunkt für jeden abgeschlossenen Trade und wandelt diesen Wert in einen „datetime“-Typ um. Mit HistoryDealGetDouble(ticket, DEAL_PRICE) wird der Schlusskurs ermittelt, und mit HistoryDealGetDouble(ticket, DEAL_PROFIT) wird der Gewinn ermittelt. Das entsprechende Array am Index h enthält jeden dieser Werte. Zuletzt ermittelt das Programm das Ergebnis des Trades. Das Ergebnis wird als „WIN“ erfasst, wenn der Gewinn größer als null ist. Das Ergebnis wird als „LOSS“ erfasst, wenn der Gewinn unter null liegt. „Break Even“ ist das Ergebnis, wenn der Gewinn genau null beträgt. Durch die Umwandlung numerischer Gewinnstatistiken in für Menschen lesbare Informationen ermöglicht diese Phase eine schnelle Analyse und ein schnelles Verständnis des Trading-Journals. 

Wenn dieser Vorgang abgeschlossen ist, enthalten die Arrays alle Schließungsdaten in der richtigen Reihenfolge und entsprechend den Trades. Diese methodische Vorgehensweise gewährleistet, dass jede Transaktion im Trading-Journal über die erforderlichen Ein- und Schließungsdaten verfügt, die zur Erfassung in der Datei bereitstehen, um eine transparente und professionelle Handelsaufzeichnung zu gewährleisten.

 

Schlussfolgerung

In diesem Artikel haben wir uns damit befasst, wie man Trading-Datendateien in MQL5 verarbeitet, indem sowohl Eröffnungs- als auch Schließungsinformationen erfasst werden, darunter Trade-ID, Symbol, Auftragstyp, Losgröße, Eröffnungszeit, Eröffnungskurs, Stop-Loss, Take-Profit, Schlusszeit, Schlusskurs, Gewinn und Ergebnis. Wir haben gelernt, wie man Daten in dynamischen Arrays speichert, Transaktionsdetails aus dem Kontoverlauf abruft und diese der Reihe nach in eine Datei schreibt und dabei Genauigkeit und Ordnung beibehält. Mit diesen Schritten haben Sie die Grundlagen für die Dateiverwaltung in MQL5 geschaffen und ein gut strukturiertes und benutzerfreundliches Trading-Journal eingerichtet, in dem alle wichtigen Trading-Daten zur späteren Überprüfung und Analyse gespeichert und geordnet werden können.