Einführung in MQL5 (Teil 30): Beherrschung der API- und WebRequest-Funktion in MQL5 (IV)

Einführung

Willkommen zurück zu Teil 30 der Serie „Einführung in MQL5!“ In diesem Artikel setzen wir unsere Erkundung der Arbeit mit externen APIs in MQL5 fort und gehen dabei über die einfache Datenextraktion und grundlegende Anfragen hinaus. Sie haben bereits gesehen, wie man eine Anfrage stellt, eine Antwort erhält, die Rohdaten bereinigt und die Ergebnisse in verwendbare Komponenten aufteilt.

Im vorangegangenen Artikel haben wir die Daten der letzten fünf Tageskerzen ermittelt und verarbeitet. Wir haben ihre Zusammensetzung analysiert, überflüssige Zeichen entfernt und jede Kerze in ihre einzelnen Elemente zerlegt. Jetzt, wo die Rohstoffe klar getrennt sind, ist es an der Zeit, sie besser zu ordnen.

Sie werden lernen, wie Sie vergleichbare Elemente aus verschiedenen Kerzen in ihren eigenen Reihen organisieren können, anstatt mit jeder Kerze einzeln zu arbeiten. Ein einziges Array enthält zum Beispiel alle Öffnungszeiten der einzelnen Kerzen. Die Eröffnungskurse, die Höchst- und Tiefstkurse, die Schlusskurse, die Volumina und alle anderen Komponenten der Kerze, die Sie untersuchen möchten, werden alle der gleichen Analyse unterzogen. Der Vergleich von Zahlen über mehrere Tage hinweg, das Erkennen von Trends, die Durchführung von Berechnungen und die Aufbereitung der Daten für Indikatoren oder Handelslogiken werden durch diesen methodischen Ansatz vereinfacht. Nach der Lektüre dieses Artikels verfügen Sie über eine klare und effektive Methode zur Anordnung von API-Kerzendaten, die die Lesbarkeit, Skalierbarkeit und Verständlichkeit Ihres MQL5-Codes verbessert und ihn für komplexere Analysen vorbereitet.

 

Gruppierung aller Öffnungszeiten in einem einzigen Array

Wir beginnen damit, alle Öffnungszeiten der vielen Kerzen in einem einzigen Array zusammenzufassen. Zuvor wurde beim Abrufen und Bereinigen der Daten aus der API-Antwort die Öffnungszeit jeder Kerze separat gespeichert. Um den Zugriff und die Verarbeitung zu erleichtern, werden sie nun in einem einzigen strukturierten Array zusammengefasst, anstatt sie getrennt zu halten. Wir erzeugen eine korrekte Zeitstempelfolge, die der Reihenfolge der Kerzen entspricht, indem wir alle Öffnungszeiten in einem einzigen Array speichern. Die Arbeit mit zeitbasierten Berechnungen, wie z. B. das Erkennen von Mustern, das Berechnen der Intervalle zwischen Kerzen, der Vergleich von Daten oder das Koordinieren der Zeiten mit anderen Kerzenelementen wie dem Eröffnungs-, Hoch-, Tief- oder Schlusskurs, wird dadurch erheblich vereinfacht.

Jeder Teil des Arrays hat seinen eigenen Index für die Anordnung der Elemente einer bestimmten Kerze. Der Index 0 enthält beispielsweise die Eröffnungszeit der ersten Kerze, der Index 1 die Eröffnungszeit der zweiten Kerze und so weiter. Wenn Sie das Array ausdrucken, nachdem alles gespeichert wurde, können Sie visuell überprüfen, ob die Zeiten korrekt gruppiert und angeordnet sind. Mit diesem einfachen, aber entscheidenden Schritt wird die Grundlage für die Sortierung der übrigen Kerzendaten gelegt. Die Eröffnungskurse, die Höchst- und Tiefstkurse, die Schlusskurse und die Volumina folgen alle dem gleichen Muster, das den Eröffnungszeiten folgt. Wenn Sie mit mehr Kerzen oder anspruchsvolleren Techniken arbeiten, lassen sich Ihre MQL5-Skripte leichter skalieren, Ihr Code wird verständlicher und Ihre Analysen werden durch die Gruppierung vergleichbarer Daten übersichtlicher.

Erinnern Sie sich daran, dass wir die Antwort des Servers in ein String-Array für Tageskerzen unterteilt und im vorherigen Teil alle unnötigen Zeichen entfernt haben? Das Komma wurde als Trennzeichen verwendet, um die Daten jeder Kerze in verschiedene Elemente zu unterteilen. Wir haben allerdings noch nicht angegeben, welcher Ort innerhalb jedes Split-Arrays mit der Öffnungszeit übereinstimmt. Bevor wir irgendetwas gruppieren, müssen wir das erst einmal feststellen.

Die Öffnungszeit wird immer an der gleichen Stelle angezeigt, da alle Kerzen im Datensatz in der gleichen Reihenfolge angeordnet sind. Wir können die Eröffnungszeit von jeder der verbleibenden Kerzen auf die gleiche Weise extrahieren, nachdem wir diese Position von der ersten Kerze verifiziert haben. Auf diese Weise können wir alle Öffnungszeiten in einem einzigen, übersichtlichen Feld zusammenfassen, auf das man später einfach zugreifen und das man nutzen kann.

Beispiel:

//DAY 1
string day1_data = candle_data[0];
StringReplace(day1_data,"[[","");
StringReplace(day1_data,"\"","");

string day1_data_array[];
StringSplit(day1_data,',',day1_data_array);
ArrayPrint(day1_data_array);

day1_data_array[]:

 1763424000000,              // opening time (0)
 92215.14000000,             // open price (1)
 93836.01000000,             // high price (2)
 89253.78000000,             // low price (3)
 92960.83000000,             // close price (4)
 39835.14769000,             // volume (5)
 1763510399999,              // closing time (6)
 3641033186.30045840,        // quote asset volume (7)
 8786593,                    // number of trades (8)
 20130.95957000,             // taker buy base asset volume (9)
 1841176605.14182350,        // taker buy quote asset volume (10)
 0                           // placeholder (11)

Nach Prüfung des Ergebnisses unserer geteilten Daten können wir feststellen, dass die Öffnungszeit als erstes Element im Array gespeichert wird. Das bedeutet, dass wir das Datenfeld für den ersten Tag verwenden können, um die Eröffnungszeit der ersten Kerze zu erhalten, die bei Index 0 steht.

Beispiel:

Print(day1_data_array[0]);

Dieser Wert befindet sich am Index 0 des Arrays, wie aus dem ersten Element der Tageskerzendaten ersichtlich ist. Die Ausgabe, die den genauen Zeitpunkt des Öffnens der Kerze angibt, wird in Millisekunden angezeigt. Anders ausgedrückt: Die Zahl, die Sie sehen, ist die genaue Öffnungszeit der Kerze und ist ein Zeitstempel, der in Millisekunden angegeben wird.  

Es ist derzeit nicht möglich, die Öffnungszeit als tatsächliches Datum und Uhrzeit in MQL5 zu verwenden, da sie als Zeichenkette vorliegt. Die Zeichenkette muss zunächst in einen geeigneten Datentyp umgewandelt werden, um sie korrekt zu verarbeiten oder zusammen mit anderen Kerzenöffnungszeiten zu speichern. Zunächst dividieren wir den vom Server angegebenen Zeitwert durch 1000, um ihn in Sekunden umzurechnen, da er in Millisekunden gemessen wird. Diese Änderung ist von entscheidender Bedeutung, da das Basisformat von MQL5 datetime Sekunden und nicht Millisekunden sind. Nach der Konvertierung können wir das Ergebnis in einem Datetime-Array speichern, das es uns ermöglicht, Berechnungen anzustellen, Öffnungszeiten zu vergleichen oder die Werte für weitere Analysen zu verwenden.

Beispiel:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

   WebRequest(method, url, headers, time_out, data, result, result_headers);
   string server_result = CharArrayToString(result);
// Print(server_result);

   string candle_data[];
   int array_count = StringSplit(server_result,']', candle_data);

//DAY 1
   string day1_data = candle_data[0];
   StringReplace(day1_data,"[[","");
   StringReplace(day1_data,"\"","");

   string day1_data_array[];
   StringSplit(day1_data,',',day1_data_array);
//  ArrayPrint(day1_data_array);

//DAY 2
   string day2_data = candle_data[1];
   StringReplace(day2_data,",[","");
   StringReplace(day2_data,"\"","");

   string day2_data_array[];
   StringSplit(day2_data,',',day2_data_array);

//DAY 3

   string day3_data = candle_data[2];
   StringReplace(day3_data,",[","");
   StringReplace(day3_data,"\"","");

   string day3_data_array[];
   StringSplit(day3_data,',',day3_data_array);

//DAY 4

   string day4_data = candle_data[3];
   StringReplace(day4_data,",[","");
   StringReplace(day4_data,"\"","");

   string day4_data_array[];
   StringSplit(day4_data,',',day4_data_array);

//DAY 5

   string day5_data = candle_data[4];
   StringReplace(day5_data,",[","");
   StringReplace(day5_data,"\"","");

   string day5_data_array[];
   StringSplit(day5_data,',',day5_data_array);

// Opening Time Array
   long day1_time_s = (long)StringToInteger(day1_data_array[0])/1000;
   datetime day1_time = (datetime)day1_time_s;
   Print(day1_time);

//---
   return(INIT_SUCCEEDED);
  }

Ausgabe:

Erläuterung:

Da die Eröffnungszeit, die dem ersten Element entnommen wurde, zunächst als Zeichenkette vorliegt, kann sie nicht direkt in MQL5-Operationen verwendet werden. Wir wandeln sie in ein Format um, das von MQL5 als legitime Zeit akzeptiert wird, nachdem wir sie zunächst in eine ganze Zahl umgewandelt haben. Diese Umrechnung garantiert, dass der Wert problemlos verarbeitet, gespeichert und mit anderen Kerzenzeiten verglichen werden kann. Wir speichern diese Zahl in einer Long-Integer-Variablen, nachdem wir die Millisekunden in Sekunden umgerechnet haben. Dank des Typs Long-Integer können wir sicher mit großen Zahlen umgehen, wie sie beim Zählen von Millisekunden über viele Jahre hinweg typisch sind.

Diese Ganzzahl vom Typ long wird dann in den Datentyp datetime umgewandelt. In dieser Phase wird der numerische Rohwert in eine geeignete Datums- und Zeitdarstellung umgewandelt, die MQL5 versteht. Der Wert kann in einem Array von Öffnungszeiten gespeichert oder für Berechnungen und Vergleiche verwendet werden, sobald er im Datetime-Format vorliegt. Der zweite Tag wird dann nach dem gleichen Verfahren ablaufen. Wir nehmen die Öffnungszeit aus den Daten des zweiten Tages, wandeln sie von Text in ein brauchbares Zeitformat um und speichern oder zeigen sie an, genau wie wir es mit der ersten Kerze gemacht haben. Damit ist gewährleistet, dass die Öffnungszeit am zweiten Tag mit den anderen Kerzen zusammengelegt werden kann und die gleiche Struktur aufweist.

Beispiel:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

   WebRequest(method, url, headers, time_out, data, result, result_headers);
   string server_result = CharArrayToString(result);
// Print(server_result);

   string candle_data[];
   int array_count = StringSplit(server_result,']', candle_data);

//DAY 1
   string day1_data = candle_data[0];
   StringReplace(day1_data,"[[","");
   StringReplace(day1_data,"\"","");

   string day1_data_array[];
   StringSplit(day1_data,',',day1_data_array);
//  ArrayPrint(day1_data_array);

//DAY 2
   string day2_data = candle_data[1];
   StringReplace(day2_data,",[","");
   StringReplace(day2_data,"\"","");

   string day2_data_array[];
   StringSplit(day2_data,',',day2_data_array);

//DAY 3

   string day3_data = candle_data[2];
   StringReplace(day3_data,",[","");
   StringReplace(day3_data,"\"","");

   string day3_data_array[];
   StringSplit(day3_data,',',day3_data_array);

//DAY 4

   string day4_data = candle_data[3];
   StringReplace(day4_data,",[","");
   StringReplace(day4_data,"\"","");

   string day4_data_array[];
   StringSplit(day4_data,',',day4_data_array);

//DAY 5

   string day5_data = candle_data[4];
   StringReplace(day5_data,",[","");
   StringReplace(day5_data,"\"","");

   string day5_data_array[];
   StringSplit(day5_data,',',day5_data_array);

// Opening Time Array

   long day1_time_s = (long)StringToInteger(day1_data_array[0])/1000;
   datetime day1_time = (datetime)day1_time_s;

   long day2_time_s = (long)StringToInteger(day2_data_array[0])/1000;
   datetime day2_time = (datetime)day2_time_s;
   Print("DAY 1 TIME: ", day1_time,"\nDAY 2 TIME: ",day2_time);
//---
   return(INIT_SUCCEEDED);
  }

Ausgabe:

Erläuterung:

Betrachten Sie die Öffnungszeit des String-Arrays als eine extrem genaue Uhr, die die Zeit in Millisekunden anzeigt. Es ist schwierig, sie als Standardzeit zu lesen oder zu verstehen, obwohl sie die Zeit genau misst, da der Wert immer noch nur eine Zahlenfolge ist.

Diese Zeichenfolge muss zunächst in eine Zahl umgewandelt werden. Dies ist vergleichbar mit der Erkenntnis, dass der aufgeschriebene Stoppuhrwert eine echte Zahl ist, die Sie für Berechnungen verwenden können. Da die meisten Systeme, die Datums- und Zeitangaben verarbeiten, seit der Unix-Epoche in Sekunden und nicht in Millisekunden arbeiten, teilen wir den resultierenden Wert durch 1000, um ihn von Millisekunden in Sekunden umzurechnen. Um in das Uhrensystem zu passen, ist es vergleichbar mit der Umwandlung winziger Sekundenbruchteile in ganze Sekunden. Wir konvertieren den Wert in datetime, nachdem wir ihn in Sekunden umgewandelt haben. Diese Phase markiert die exakte Eröffnung der zweiten Tageskerze und ermöglicht es dem System, den Wert als definitiven Zeitpunkt zu verstehen.

Die Öffnungszeiten sind deutlich sichtbar und für den Menschen lesbar, wenn wir die Zeiten für den ersten und zweiten Tag ausdrucken. Dies ermöglicht uns, sie zu bewerten, zu vergleichen und in Berechnungen oder Indikatoren zu verwenden. Der Wert gibt uns einen genauen Zeitstempel für unser Projekt, indem er den Punkt auf dem Chart darstellt, an dem die Kerze offiziell begann, sich zu bilden.

Jetzt, da wir wissen, wie man die ersten beiden Tageskerzen umrechnet und den Eröffnungszeitpunkt bestimmt, ist es an der Zeit, den gleichen Prozess auf die folgenden drei Tage anzuwenden. Wir können die Eröffnungszeit für jede Kerze genau aufzeichnen, indem wir in jedem String-Array nach der entsprechenden Tageskerze suchen, den ersten Wert von Millisekunden in Sekunden umwandeln und ihn dann in einen Datetime-Typ umwandeln. Dadurch wird gewährleistet, dass jede der fünf täglichen Kerzenöffnungszeiten zuverlässig im Datetime-Format aufgezeichnet wird, sodass sie für die Verwendung in Handelsmethoden oder für zusätzliche Analysen in einem einzigen Array gruppiert werden können.

Beispiel:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

   WebRequest(method, url, headers, time_out, data, result, result_headers);
   string server_result = CharArrayToString(result);
// Print(server_result);

   string candle_data[];
   int array_count = StringSplit(server_result,']', candle_data);

//DAY 1
   string day1_data = candle_data[0];
   StringReplace(day1_data,"[[","");
   StringReplace(day1_data,"\"","");

   string day1_data_array[];
   StringSplit(day1_data,',',day1_data_array);
//  ArrayPrint(day1_data_array);


//DAY 2
   string day2_data = candle_data[1];
   StringReplace(day2_data,",[","");
   StringReplace(day2_data,"\"","");

   string day2_data_array[];
   StringSplit(day2_data,',',day2_data_array);

//DAY 3

   string day3_data = candle_data[2];
   StringReplace(day3_data,",[","");
   StringReplace(day3_data,"\"","");

   string day3_data_array[];
   StringSplit(day3_data,',',day3_data_array);

//DAY 4

   string day4_data = candle_data[3];
   StringReplace(day4_data,",[","");
   StringReplace(day4_data,"\"","");

   string day4_data_array[];
   StringSplit(day4_data,',',day4_data_array);

//DAY 5

   string day5_data = candle_data[4];
   StringReplace(day5_data,",[","");
   StringReplace(day5_data,"\"","");

   string day5_data_array[];
   StringSplit(day5_data,',',day5_data_array);

// Opening Time Array

   long day1_time_s = (long)StringToInteger(day1_data_array[0])/1000;
   datetime day1_time = (datetime)day1_time_s;

   long day2_time_s = (long)StringToInteger(day2_data_array[0])/1000;
   datetime day2_time = (datetime)day2_time_s;

   long day3_time_s = (long)StringToInteger(day3_data_array[0])/1000;
   datetime day3_time = (datetime)day3_time_s;

   long day4_time_s = (long)StringToInteger(day4_data_array[0])/1000;
   datetime day4_time = (datetime)day4_time_s;

   long day5_time_s = (long)StringToInteger(day5_data_array[0])/1000;
   datetime day5_time = (datetime)day5_time_s;

   Print("DAY 1 TIME: ", day1_time,"\nDAY 2 TIME: ",day2_time,"\nDAY 3 TIME: ",day3_time,"\nDAY 4 TIME: ",day4_time,"\nDAY 5 TIME: ",day5_time);

  }

Ausgabe:

Indem wir für die verbleibenden drei Kerzen das gleiche Verfahren wie für die ersten beiden angewandt haben, konnten wir alle fünf Öffnungszeiten ermitteln. Das erste Array-Element jedes Tages wurde in datetime umgewandelt, nachdem es von einer Zeichenkette in ein Long-Integer-Wert der Sekunden umgewandelt worden war. Das Ergebnis ist ein vollständiger Satz von Öffnungszeiten, der überprüft werden kann, indem alle fünf ausgedruckt und dann zusammengefügt oder geprüft werden.

Jede der fünf täglichen Öffnungszeiten der Kerzen wurde erfolgreich extrahiert. Der nächste Schritt besteht darin, ein Datetime-Array zu erstellen, damit unser Programm mit all diesen Öffnungszeiten in einer einzigen Sammlung arbeiten kann.

Beispiel:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

   WebRequest(method, url, headers, time_out, data, result, result_headers);
   string server_result = CharArrayToString(result);
// Print(server_result);

   string candle_data[];
   int array_count = StringSplit(server_result,']', candle_data);
   
   //DAY 1
   string day1_data = candle_data[0];
   StringReplace(day1_data,"[[","");
   StringReplace(day1_data,"\"","");
   
   string day1_data_array[];
   StringSplit(day1_data,',',day1_data_array);
 //  ArrayPrint(day1_data_array);
     
  //DAY 2
   string day2_data = candle_data[1];
   StringReplace(day2_data,",[","");
   StringReplace(day2_data,"\"","");
   
   string day2_data_array[];
   StringSplit(day2_data,',',day2_data_array);
   
   //DAY 3
   
   string day3_data = candle_data[2];
   StringReplace(day3_data,",[","");
   StringReplace(day3_data,"\"","");
   
   string day3_data_array[];
   StringSplit(day3_data,',',day3_data_array);
      
   //DAY 4
   
   string day4_data = candle_data[3];
   StringReplace(day4_data,",[","");
   StringReplace(day4_data,"\"","");
   
   string day4_data_array[];
   StringSplit(day4_data,',',day4_data_array);
   
   //DAY 5
   
   string day5_data = candle_data[4];
   StringReplace(day5_data,",[","");
   StringReplace(day5_data,"\"","");
   
   string day5_data_array[];
   StringSplit(day5_data,',',day5_data_array);   
   
 // Opening Time Array
   
  long day1_time_s =  (long)StringToInteger(day1_data_array[0])/1000;
  datetime day1_time = (datetime)day1_time_s;
  
  long day2_time_s =  (long)StringToInteger(day2_data_array[0])/1000;
  datetime day2_time = (datetime)day2_time_s;
  
  long day3_time_s =  (long)StringToInteger(day3_data_array[0])/1000;
  datetime day3_time = (datetime)day3_time_s;
  
  long day4_time_s =  (long)StringToInteger(day4_data_array[0])/1000;
  datetime day4_time = (datetime)day4_time_s;
  
  long day5_time_s =  (long)StringToInteger(day5_data_array[0])/1000;
  datetime day5_time = (datetime)day5_time_s;
  
  datetime OpenTime[5] = {day1_time, day2_time, day3_time, day4_time, day5_time};
  ArrayPrint(OpenTime);
}

Ausgabe:

Erläuterung:

Es wurde ein einziges Array erstellt, indem die fünf täglichen Kerzeneröffnungszeiten kombiniert wurden. Anstatt jeden Tag mit mehreren Variablen zu jonglieren, haben wir es bei diesem Konzept mit einem einzigen, gut organisierten Container zu tun, der uns einen effizienten Umgang mit den Daten ermöglicht. Wir haben ArrayPrint (OpenTime) nach der Definition des Arrays verwendet. Das komplette Array wurde von dieser Funktion im Log-Fenster des MetaTrader ausgegeben. Wir konnten uns davon überzeugen, dass das Konvertierungsverfahren effektiv war und dass die Öffnungszeit jedes Tages korrekt im Array positioniert wurde, indem wir alle gespeicherten Datumswerte sahen.

Ein Array kann angezeigt werden, ohne von einer einzigen Funktion abhängig zu sein. Wir können jedes Element unabhängig ausdrucken, indem wir durch das Array iterieren, und wir können sogar die Ausgabe zur Verdeutlichung ändern. Für eine übersichtlichere Zusammenfassung ist es auch möglich, alle Werte in eine Zeile zu schreiben. Diese Flexibilität gibt uns die vollständige Kontrolle über die Darstellung des Arrays.

Beispiel:

Print("DAY 1 TIME: ", OpenTime[0],"\nDAY 2 TIME: ",OpenTime[1],"\nDAY 3 TIME: ",OpenTime[2],"\nDAY 4 TIME: ",OpenTime[3],"\nDAY 5 TIME: ",OpenTime[4]);

Vom ersten bis zum fünften Tag entspricht jede Zahl in der Matrix der Öffnungszeit einer bestimmten Kerze. Sie können leicht feststellen, welche Öffnungszeit mit welcher Kerze übereinstimmt, wenn sie separat angezeigt werden. Dies ist hilfreich, wenn Sie bestimmte Einträge untersuchen oder Fehler beheben möchten, anstatt den gesamten Satz auf einmal zu betrachten.

 

Gruppierung aller offenen Preise in einem einzigen Array

Aus der täglichen Datenanordnung geht hervor, dass der Eröffnungskurs das Element ist, das in jedem String-Array unmittelbar nach der Eröffnungszeit erscheint. Daher haben wir uns in diesem Teil auf die Bestimmung des Eröffnungskurses jeder Kerze konzentriert.

Nachdem wir den Eröffnungskurs mithilfe des entsprechenden Index im String-Array gefunden hatten, haben wir den String-Wert in einen Double-Datentyp umgewandelt, damit er in MQL5-Berechnungen verwendet werden kann. Nach der Umrechnung erhielten wir die Eröffnungspreise für jede der fünf Kerzen nach demselben Verfahren. Dies ermöglichte es uns, den Eröffnungskurs für jeden Tag konsistent und sauber zu extrahieren und die Daten so aufzubereiten, dass wir, wie bei den Eröffnungszeiten, alle Informationen in einem einzigen Array zusammenfassen können.

  1763424000000,       // opening time (0)
  92215.14000000,      // open price (1)
  93836.01000000,      // high price (2)
  89253.78000000,      // low price (3)
  92960.83000000,      // close price (4)
  39835.14769000,      // volume (5)
  1763510399999,       // closing time (6)
  3641033186.30045840, // quote asset volume (7)
  8786593,             // number of trades (8)
  20130.95957000,      // taker buy base asset volume (9)
  1841176605.14182350, // taker buy quote asset volume (10)
  0                    // placeholder (11)

Beispiel:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

   WebRequest(method, url, headers, time_out, data, result, result_headers);
   string server_result = CharArrayToString(result);
// Print(server_result);

   string candle_data[];
   int array_count = StringSplit(server_result,']', candle_data);

//DAY 1
   string day1_data = candle_data[0];
   StringReplace(day1_data,"[[","");
   StringReplace(day1_data,"\"","");

   string day1_data_array[];
   StringSplit(day1_data,',',day1_data_array);
//  ArrayPrint(day1_data_array);

//DAY 2
   string day2_data = candle_data[1];
   StringReplace(day2_data,",[","");
   StringReplace(day2_data,"\"","");

   string day2_data_array[];
   StringSplit(day2_data,',',day2_data_array);

//DAY 3

   string day3_data = candle_data[2];
   StringReplace(day3_data,",[","");
   StringReplace(day3_data,"\"","");

   string day3_data_array[];
   StringSplit(day3_data,',',day3_data_array);

//DAY 4

   string day4_data = candle_data[3];
   StringReplace(day4_data,",[","");
   StringReplace(day4_data,"\"","");

   string day4_data_array[];
   StringSplit(day4_data,',',day4_data_array);

//DAY 5

   string day5_data = candle_data[4];
   StringReplace(day5_data,",[","");
   StringReplace(day5_data,"\"","");

   string day5_data_array[];
   StringSplit(day5_data,',',day5_data_array);

// Opening Time Array

   long day1_time_s = (long)StringToInteger(day1_data_array[0])/1000;
   datetime day1_time = (datetime)day1_time_s;

   long day2_time_s = (long)StringToInteger(day2_data_array[0])/1000;
   datetime day2_time = (datetime)day2_time_s;

   long day3_time_s = (long)StringToInteger(day3_data_array[0])/1000;
   datetime day3_time = (datetime)day3_time_s;

   long day4_time_s = (long)StringToInteger(day4_data_array[0])/1000;
   datetime day4_time = (datetime)day4_time_s;

   long day5_time_s = (long)StringToInteger(day5_data_array[0])/1000;
   datetime day5_time = (datetime)day5_time_s;

   datetime OpenTime[5] = {day1_time, day2_time, day3_time, day4_time, day5_time};

// Opening Price Array
   double day1_open = StringToDouble(day1_data_array[1]);

//---
   return(INIT_SUCCEEDED);
  }

Erläuterung:

Wir begannen damit, den Eröffnungskurs im Datenfeld des ersten Tages zu ermitteln. Wir haben uns vergewissert, dass der Eröffnungskurs im Index 1 gehalten wurde, nachdem wir uns die Struktur der Tageskerzen angesehen haben. Das war sinnvoll, da die Eröffnungszeit durch den Index 0 und der Eröffnungskurs logischerweise durch den Index 1 repräsentiert wurde. Nachdem wir den Index bestimmt haben, wandeln wir die Zeichenkette in einen Double-Datentyp um. Da Preisangaben in der Regel Dezimalzahlen enthalten und ihre Speicherung als Ganzzahlen oder Zeichenketten korrekte Berechnungen verhindern würde, haben wir den Typ double verwendet. Der Wert wurde in double umgewandelt, damit er für mathematische Operationen wie Durchschnittswerte, Vergleiche und zusätzliche Analysen verwendet werden kann.

Um dies besser zu verstehen, stellen Sie sich die Rohdaten, die wir von der API erhalten haben, als schriftliche Informationen vor. Der Eröffnungspreis war wie eine mit einem Stift gekritzelte Zahl in Textform angegeben. Der Computer interpretierte es als Text, obwohl es eine Zahl zu sein schien. Im Grunde haben wir die Zahl mit einer Umrechnungsfunktion in einen Taschenrechner umgewandelt, damit sie für tatsächliche Berechnungen verwendet werden kann. Der Wert wurde in dieser Phase von einer einfachen Textbemerkung in eine verwendbare numerische Zahl geändert. Nach dieser Umrechnung konnten wir den korrekten doppelten Wert in day1_open erfassen und das gleiche Verfahren für die übrigen Kerzen durchführen.

Da wir nun gelernt haben, wie wir den Eröffnungskurs für die erste Kerze bestimmen und umrechnen können, haben wir uns entschieden, das gleiche Verfahren für die anderen vier Kerzen anzuwenden. Die Strategie ist dieselbe geblieben. Alles, was wir getan haben, war, uns an das gleiche Muster wie zuvor zu halten. Um sicherzustellen, dass wir den richtigen Eröffnungskurs für jeden der anderen Tage ausgewählt haben, haben wir zunächst überprüft, ob jedes String-Array den richtigen Index hat. Ähnlich wie am ersten Tag erscheinen auch die Eröffnungskurse für den zweiten, dritten, vierten und fünften Tag im Index 1 der entsprechenden Arrays. Der Wert muss vom String-Format in den Double-Datentyp geändert werden, nachdem die Position überprüft wurde. Da Preisangaben in der Regel Dezimalzahlen enthalten, war diese Umrechnung von entscheidender Bedeutung. Wenn wir z. B. einen Preis wie 1,08512 oder 154,72 in Berechnungen verwenden oder mit anderen Preisen vergleichen wollen, muss er als double erfasst werden. MetaTrader würde ihn nicht als numerischen Wert behandeln, wenn wir ihn als Zeichenkette belassen würden.

Der Vorgang ist vergleichbar mit der Eingabe gedruckter Zahlen in einen Taschenrechner. Der Taschenrechner kann nur mit tatsächlichen Zahlenwerten arbeiten, auch wenn die Zahlen auf dem Papier gültig zu sein scheinen. Wir haben die Werte im Wesentlichen so vorbereitet, dass MQL5 sie in Zukunft für Berechnungen verwenden kann, indem wir jeden Eröffnungspreis von String in double umgewandelt haben.

Beispiel:

// Opening Price Array
 double day1_open = StringToDouble(day1_data_array[1]);
 double day2_open = StringToDouble(day2_data_array[1]);
 double day3_open = StringToDouble(day3_data_array[1]);
 double day4_open = StringToDouble(day4_data_array[1]);
 double day5_open = StringToDouble(day4_data_array[1]);
 
 double OpenPrice[5] = {day1_open, day2_open, day3_open, day4_open, day5_open};
 
 Print("DAY 1 OPEN PRICE: ", OpenPrice[0],"\nDAY 2 OPEN PRICE: ",OpenPrice[1],"\nDAY 3 OPEN PRICE: "
  ,OpenPrice[2],"\nDAY 4 OPEN PRICE: ",OpenPrice[3],"\nDAY 5 OPEN PRICE: ",OpenPrice[4]);

Ausgabe:

Erläuterung:

Die Zeichenkette der Eröffnungspreise aus dem Datenfeld eines bestimmten Tages wird von jeder der ersten vier Zeilen übernommen, in einen numerischen Wert mit präziser Dezimalstellenanzahl umgewandelt und in einer Variablen des Typs double für diesen Tag zugewiesen. Preise müssen von einer Zeichenkette in double konvertiert werden, da sie Dezimalstellen enthalten und als Fließkommawerte behandelt werden müssen, um Berechnungen für Arithmetik, Vergleiche und Indikatoren durchzuführen. Da das zweite Element der Split-Daten eines jeden Tages (Index 1) zuvor festgelegt wurde, um die Position des Eröffnungspreises in der Kerzenstruktur zu repräsentieren, wird es im Konvertierungsschritt gelesen.

Die fünfte Konvertierung unterscheidet sich von den anderen vier dadurch, dass sie erneut aus dem day4_data_array liest, während die ersten vier den Eröffnungskurs aus dem tagesinternen Datenarray ermitteln. Ohne eine Korrektur wäre der Eröffnungskurs des fünften Tages derselbe wie der des vierten Tages. Um sicherzustellen, dass die Preise für jeden Tag aus dem richtigen Element stammen, sollten Sie das Quell-Array für die fünfte Konvertierung überprüfen und es so ändern, dass es das Daten-Array für den fünften Tag verwendet.

Alle fünf Preise werden in einem einzigen Array zusammengefasst, sobald der Startpreis eines jeden Tages in eine numerische Zahl umgewandelt wurde. Es ist einfach, Berechnungen durchzuführen, Trends zu untersuchen oder sie in Indikatoren zu verwenden, wenn sie sich alle in einem Feld befinden. Verglichen mit der Verwaltung der Preise als einzelne Textstrings ist dies zuverlässiger und effizienter. Alle fünf Preise werden in einem einzigen Array zusammengefasst, nachdem der Eröffnungspreis für jeden Tag in einen numerischen Wert umgewandelt wurde. Berechnungen, Trendanalysen und die Verwendung von Indikatoren werden durch die Zusammenfassung in einem einzigen Feld vereinfacht. Sie ist zuverlässiger und effektiver als die Behandlung der Preise als einzelne Textstrings.

Schließlich wird der Eröffnungskurs für jeden Tag auf verständliche Weise angezeigt, indem jedes Array-Element nach Index ausgedruckt wird. Anhand des Ausdrucks können Sie schnell überprüfen, ob alle Konvertierungen und Gruppierungen erfolgreich waren und ob die Datenfolge Ihren Erwartungen entspricht. Vergewissern Sie sich vor der Verwendung der Quellindizes und Array-Namen in Berechnungen, dass diese korrekt sind.

 

Gruppierung aller Schlusskurse in einem einzigen Array

Um die Schlusskurse aus jeder Tageskerze zu extrahieren, wenden wir denselben methodischen Prozess an, den wir zuvor bei der Bearbeitung der Eröffnungskurse verwendet haben. Wir kennen bereits die genaue Position des Schlusskurses in jedem Feld, da die Daten für jede Kerze einheitlich organisiert sind. Da wir die Elemente nicht erraten oder durchsuchen müssen, vereinfacht diese vorhersehbare Struktur den Extraktionsprozess. Vielmehr verweisen wir einfach auf die richtige Stelle, da wir wissen, dass jede Kerze dem gleichen Muster folgt. Solange sich die Datenstruktur nicht ändert, können wir dank dieser Konsistenz einen zuverlässigen Code erstellen, der für eine beliebige Anzahl von Kerzen funktioniert.

Der nächste Schritt besteht darin, den Wert abzurufen, nachdem festgestellt wurde, welche Position in den Daten eines jeden Tages den Schlusskurs enthält. Die Daten werden zu diesem Zeitpunkt noch als Text im String-Array gespeichert. Die Zahl muss in einen numerischen Typ umgewandelt werden, bevor sie in Berechnungen verwendet werden kann, auch wenn es sich um einen Preis zu handeln scheint. Damit MQL5 den Wert als reelle Zahl behandeln kann, müssen wir den Wert aus dem Array extrahieren und in ein double umwandeln.

Berechnungen, Vergleiche und andere Verarbeitungen können fehlerfrei durchgeführt werden, wenn der Schlusskurs vom Typ double ist. Da MQL5 mit Strings und Zahlen ganz anders umgeht und die Plattform den richtigen Datentyp benötigt, bevor mathematische Operationen angewandt werden können, ist dieser Konvertierungsschritt entscheidend. Das nächste Ziel besteht darin, sie zu ordnen, nachdem jeder Schlusskurs in eine nützliche Zahl umgewandelt wurde. Wir fassen die Werte in einem einzigen Array zusammen, das die Schlusskurse für jeden der fünf Tage enthält, anstatt sie auf mehrere Variablen zu verteilen. Dank dieses Designs können wir leichter auf die Daten zugreifen und einen saubereren Code schreiben.

Darüber hinaus können wir die Werte in einer Schleife durchlaufen, Berechnungen durchführen, sie in Indikatoren einspeisen, den Schlusskurs eines Tages mit dem eines anderen vergleichen und jede Analyse durchführen, für die strukturierte Daten erforderlich sind, indem wir sie in einem Array speichern. Da sie es uns ermöglichen, mehrere verknüpfte Werte als eine einzige, gut organisierte Einheit zu verwalten, anstatt jedes Element unabhängig zu behandeln, helfen Arrays dabei, unseren Arbeitsablauf zu rationalisieren. Um sicherzugehen, dass alles korrekt erfasst wurde, können wir die Schlusskurse ausdrucken oder anzeigen, sobald das Feld aufgebaut und gefüllt ist. Die effektive Extraktion und Umwandlung wird durch diese entscheidende Überprüfungsphase bestätigt. Außerdem ist es einfacher, die Daten visuell zu überprüfen und sicherzustellen, dass keine Fehler vorhanden sind, wenn alle Schlusskurse zusammen angezeigt werden.

 1763424000000,     // opening time (0)
 92215.14000000,    // open price (1)
 93836.01000000,    // high price (2)
 89253.78000000,    // low price (3)
 92960.83000000,    // close price (4)
 39835.14769000,    // volume (5)

Anhand dieses Layouts wird deutlich, dass sich der Schlusskurs im Index 4, also im fünften Element des Datenfeldes, befindet. Wir suchen einfach den Index, der den Schlusskurs enthält, ändern den String-Wert in einen Double-Wert und speichern jedes Ergebnis in einem neuen Array mit demselben methodischen Verfahren. Da Preisfindungswerte mit einem numerischen Datentyp dargestellt werden müssen, der Nachkommastellen unterstützt und Dezimalstellen enthält, ist die Konvertierung in double entscheidend.

Wir fassen die Schlusskurse der fünf Tage in einem einzigen Array zusammen, nachdem wir jeden einzelnen Kurs ermittelt haben. Wie bei den Eröffnungskursen können wir so mit allen Schlusskursen auf einmal arbeiten. Diese gruppierten Daten machen es einfach, den Schlusskurs eines beliebigen Tages in Abhängigkeit vom Array-Index zu erhalten und ihn für Berechnungen, Vergleiche, grafische Darstellungen und andere Verarbeitungen innerhalb unseres Indikators oder Skripts zu verwenden.

Beispiel:

// Opening Time Array
  long day1_time_s =  (long)StringToInteger(day1_data_array[0])/1000;
  datetime day1_time = (datetime)day1_time_s;
  
  long day2_time_s =  (long)StringToInteger(day2_data_array[0])/1000;
  datetime day2_time = (datetime)day2_time_s;
  
  long day3_time_s =  (long)StringToInteger(day3_data_array[0])/1000;
  datetime day3_time = (datetime)day3_time_s;
  
  long day4_time_s =  (long)StringToInteger(day4_data_array[0])/1000;
  datetime day4_time = (datetime)day4_time_s;
  
   long day5_time_s =  (long)StringToInteger(day5_data_array[0])/1000;
  datetime day5_time = (datetime)day5_time_s;
      
  datetime OpenTime[5] = {day1_time, day2_time, day3_time, day4_time, day5_time};
   
 // Opening Price Array
 double day1_open = StringToDouble(day1_data_array[1]);
 double day2_open = StringToDouble(day2_data_array[1]);
 double day3_open = StringToDouble(day3_data_array[1]);
 double day4_open = StringToDouble(day4_data_array[1]);
 double day5_open = StringToDouble(day4_data_array[1]);
 
 double OpenPrice[5] = {day1_open, day2_open, day3_open, day4_open, day5_open}; 

 // Closing Price Array
 double day1_close = StringToDouble(day1_data_array[4]);
 double day2_close = StringToDouble(day2_data_array[4]);
 double day3_close = StringToDouble(day3_data_array[4]);
 double day4_close = StringToDouble(day4_data_array[4]);
 double day5_close = StringToDouble(day4_data_array[4]);
 
 double ClosePrice[5] = {day1_close, day2_close, day3_close, day4_close, day5_close};
 Print("DAY 1 CLOSE PRICE: ", ClosePrice[0],"\nDAY 2 CLOSE PRICE: ",ClosePrice[1],"\nDAY 3 CLOSE PRICE: "
,ClosePrice[2],"\nDAY 4 CLOSE PRICE: ",ClosePrice[3],"\nDAY 5 CLOSE PRICE: ",ClosePrice[4]);

Ausgabe:

Erläuterung:

Der erste Schritt bestand darin, herauszufinden, welcher Index den Schlusskurs darstellt. Anhand der Anordnung der Werte wird deutlich, dass der Schlusskurs für jede Kerze immer an derselben Stelle steht, sodass wir ihn mit Sicherheit für jeden Tag extrahieren können. Nachdem die Position des Schlusskurses bestätigt worden war, musste jede Zahl von einer Zeichenkette in einen numerischen Typ umgewandelt werden, der für Berechnungen verwendet werden konnte. Da Aktivitäten wie Vergleiche und Berechnungen numerische Werte erfordern und die vom Server empfangenen Daten ursprünglich im String-Format vorliegen, ist diese Übersetzung entscheidend. Das gleiche Verfahren wurde für jede der fünf Tageskerzen angewandt, wobei jeder Schlusskurs in ein numerisches Format umgewandelt wurde.

Ein einziges Array namens ClosePrice wurde erstellt, um alle täglichen Schlusskurse zu kombinieren, nachdem jeder einzelne Schlusskurs verdoppelt worden war. Da das erste Element die aktuellste Kerze und das letzte Element die fünfte Kerze in unserer Serie bezeichnet, hält dieses Array die Tagesabschlüsse in sequenzieller Reihenfolge fest. Diese Methode der Datenorganisation macht es einfach, den Schlusskurs einer bestimmten Kerze zu ermitteln oder eine Analyse über mehrere Kerzen durchzuführen. Nachdem der Schlusskurs jeder Tageskerze ermittelt worden war, musste er von einer Zeichenkette in eine Zahl umgewandelt werden, die für die Berechnungen verwendet werden konnte. Um Probleme aufgrund von Datenstrings zu vermeiden, wird in dieser Phase sichergestellt, dass alle fünf Schlusskurse in einem Format vorliegen, das für Analysen, Vergleiche und weitere Verarbeitungen verwendet werden kann.

 

Gruppierung aller Hochs in einem einzigen Array

Das Ziel dieses Abschnitts ist es, alle Hochs jeder Tageskerze in einem einzigen Array zusammenzufassen. Der erste Schritt besteht darin, zu bestimmen, welches Element in jedem Kerzen-Array dem Hoch entspricht, ähnlich wie wir es mit den Eröffnungs- und Schlusskursen gemacht haben. Anhand des Musters der Kerzen können wir den entsprechenden Index ermitteln, der an jedem Tag den höchsten Preis aufweist.

 1763424000000,     // opening time (0)
 92215.14000000,    // open price (1)
 93836.01000000,    // high price (2)
 89253.78000000,    // low price (3)
 92960.83000000,    // close price (4)
 39835.14769000,    // volume (5)

Nachdem wir den Index identifiziert haben, werden wir jedes Hoch einer Zeichenkette in eine Zahl umwandeln. Da Preise häufig Dezimalzahlen enthalten und numerische Daten für Berechnungen oder Vergleiche benötigt werden, ist diese Umrechnung erforderlich. Sobald alle Hochs umgewandelt wurden, werden wir diese Werte in einem einzigen Array zusammenfassen, von dem jeder das Hoch einer bestimmten Tageskerze darstellt. Es ist einfacher, Trends zu bewerten, Werte über viele Kerzen hinweg zu vergleichen und die Daten für Indikatoren oder Handelsmethoden zu verwenden, wenn die Hochs in einer einzigen Reihe angeordnet sind. Um eine einheitliche Vorgehensweise bei der Verarbeitung der Kerzendaten zu gewährleisten, wird dieses Verfahren ähnlich wie bei den Eröffnungs- und Schlusskursen angewandt.

Beispiel:

// High Price Array
 double day1_high = StringToDouble(day1_data_array[2]);
 double day2_high = StringToDouble(day2_data_array[2]);
 double day3_high = StringToDouble(day3_data_array[2]);
 double day4_high = StringToDouble(day4_data_array[2]);
 double day5_high = StringToDouble(day4_data_array[2]);
 
 double HighPrice[5] = {day1_high, day2_high, day3_high, day4_high, day5_high};

Erläuterung:

Hier erstellen wir ein einzelnes Array, das die Hochs von jeder Tageskerze enthält. Der erste Schritt ist die Suche nach dem Element im String-Array eines jeden Tages, das das Hoch am besten symbolisiert. Das dritte Element in jedem Tageskerzen-Array, Index 2, ist der Ort, an dem sich nach unserer Analyse der Daten der Höchstkurs befindet.

Wir wandeln den String-Wert an dieser Stelle in einen Double-Datentyp für jeden Tag um. Preiswerte enthalten häufig Dezimalzahlen; daher ermöglicht die Speicherung als numerische Werte spätere Berechnungen, Vergleiche oder Analysen. Zum Beispiel wird das dritte Element des Kerzen-Arrays des ersten Tages in einen Double-Wert umgewandelt, um day1_high zu erzeugen. Dieser Vorgang wird an den folgenden vier Tagen wiederholt.

Wir haben die Werte aus allen fünf Tagen in einem einzigen Array zusammengefasst, nachdem wir die Hochs für jeden Tag umgerechnet hatten. Es ist einfach, auf die Hochs über mehrere Kerzen hinweg zuzugreifen, sie auszuwerten oder zu ändern, da jeder Punkt im Array den Hoch eines bestimmten Tages darstellt.

 

Gruppierung aller Tiefs in einem einzigen Array

Der nächste Schritt bei der Anordnung unserer Kerzendaten ist die Zusammenfassung aller Tiefs in einem einzigen Array. Wir beginnen damit, das Tief in jeder Tageskerzenreihe zu finden, genauso wie wir es mit dem Höchst- und Eröffnungskurs getan haben. Das Tief liegt bei Index 3, dem vierten Element in jeder Kerzenreihe, wie aus den Daten hervorgeht.

Das Tief wird für jeden Tag von einem String in einen Double-Datentyp geändert. Dies garantiert die Eignung der Werte für Berechnungen, Vergleiche und weitere Analysen. Nach der Umrechnung werden die Tiefstpreise aller fünf Tageskerzen in einem einzigen Array zusammengefasst. Dieses Array macht es einfach, einzelne Tiefstpreise abzurufen und mit ihnen zu interagieren, da jeder Index für einen bestimmten Tag steht. Wir haben nun ein strukturiertes System, in dem jede Kerzenkomponente in einem separaten Feld angeordnet ist, indem die Tiefs auf diese Weise gruppiert werden. Diese Methode vereinfacht nicht nur die Datenverwaltung, sondern bereitet die Kerzendaten auch für alle Analysen, Indikatoren oder Handelsmethoden vor, die wir verwenden möchten.

Beispiel:

// Low Price Array

 double day1_low = StringToDouble(day1_data_array[3]);
 double day2_low = StringToDouble(day2_data_array[3]);
 double day3_low = StringToDouble(day3_data_array[3]);
 double day4_low = StringToDouble(day4_data_array[3]);
 double day5_low = StringToDouble(day4_data_array[3]);


  double LowPrice[5] = {day1_low, day2_low, day3_low, day4_low, day5_low};

Erläuterung:

Wir haben die Tiefstpreise für jeden der fünf Tage in einem einzigen Array aufgezeichnet, nachdem wir die Werte von Strings in Double-Werte umgewandelt und den Tiefstpreis aus den Kerzendaten für jeden Tag genommen haben. Das Drucken des Arrays bestätigt, dass die Werte für die Verwendung in Indikatoren, Strategien oder einem Expert Advisor korrekt aufbereitet und angeordnet sind. Jedem Slot ist ein bestimmter Tag zugeordnet.                                                                                                         

Schlussfolgerung

In diesem Artikel haben wir erfolgreich den nächsten Schritt bei der Organisation von API-Kerzendaten unternommen, indem wir ähnliche Elemente aus mehreren Tageskerzen in speziellen Arrays gruppiert haben. . Die Eröffnungszeiten, Eröffnungs-, Höchst-, Tiefst- und Schlusskurse jeder Kerze wurden abgerufen, umgewandelt und in strukturierten Arrays gespeichert. Der Zugriff auf bestimmte Datenpunkte, die Durchführung von Berechnungen und die Verwendung der Daten in Indikationen oder Expert Advisors werden mit dieser Methode vereinfacht. Wenn Sie diesen Beitrag zu Ende gelesen haben, werden Sie über eine klare und effektive Methode zur Verwaltung mehrerer Kerzen in MQL5 verfügen und damit die Voraussetzungen für anspruchsvollere Analysen und die Automatisierung von Handelsstrategien schaffen.