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

Einführung

Willkommen zurück zu Teil 28 der Serie Einführung in MQL5! Im vorangegangenen Artikel haben wir die Idee der APIs erforscht, die wesentlichen Parameter der Funktion WebRequest besprochen und über die Verwendung dieser Funktion für die Verbindung mit externen Servern gesprochen. Diese Lektion legte den Grundstein für das Verständnis des Datenflusses zwischen MetaTrader 5 und anderen Plattformen.

Wie ich immer sage: „Beim Programmieren ist man nur so gut wie die Projekte, an denen man gearbeitet hat.“ Und damit ist das Wesentliche dieses Teils perfekt erfasst. 

Wie üblich werden wir einen projektbasierten Ansatz wählen, um den Lernprozess praktischer und ansprechender zu gestalten. In diesem Artikel erfahren Sie alles darüber, wie eine URL funktioniert. Auch wenn dies im letzten Teil kurz erläutert wurde, werden wir es jetzt viel genauer untersuchen. Jede Komponente einer URL wird in einfache und klare Teile zerlegt, einschließlich Protokoll, Domäne, Pfad und Abfrage. Wir werden ein MQL5-Skript für unser einfaches Projekt erstellen, das die API externer Dienste nutzt, um Preisdaten in Echtzeit abzurufen. Darüber hinaus lernen Sie, wie Sie JSON-Antworten parsen und mit MQL5 bestimmte Informationen daraus extrahieren können, um die Lücke zwischen unverarbeiteten API-Daten und nützlichen Handelseinblicken zu schließen.

 

Die URL verstehen

Im letzten Artikel habe ich eine kurze Erläuterung zu URLs gegeben, aber in diesem Artikel werde ich eine detaillierte Aufschlüsselung ihrer Komponenten geben, insbesondere im Zusammenhang mit der Arbeit mit APIs.

Obwohl die von den verschiedenen Plattformen verwendeten URLs variieren, folgen sie normalerweise einer ähnlichen Reihenfolge. Die Basis-URL der Telegram-API lautet zum Beispiel

https://api.telegram.org

Und die Basis-URL für die API von Binance lautet

https://api.binance.com

Der Server, mit dem Sie sich verbinden, wird durch diese URLs identifiziert. Die Struktur ist trotz der Unterschiede in den Plattformen vergleichbar: ein Protokoll, ein Bereich und ein Weg, der zur gewünschten Ressource oder Funktion führt.

Bestandteile einer URL

Ein Bauteil ist nur ein Teil oder ein Abschnitt von etwas Größerem. Jedes der verschiedenen Teile, aus denen etwas besteht, wird als Komponente bezeichnet. Ähnlich wie diese besteht eine URL aus verschiedenen Komponenten, von denen jede eine bestimmte Funktion hat, um Ihre Software beim Auffinden von und beim Zugriff auf Daten auf einem Server zu unterstützen.

Die verschiedenen Teile, die zusammen die gesamte Adresse ergeben, werden als Bestandteile einer URL bezeichnet. Vom allgemeinen Standort bis zur genauen Ressource, die Sie abrufen möchten, steuern diese Komponenten Ihr Programm. So wie ein Auto als eine Einheit erscheint, aber aus verschiedenen Teilen besteht, von denen jeder seine eigene Funktion hat, so verhält es sich auch mit einer URL. Obwohl es sich scheinbar um eine einzige lange Adresse handelt, besteht sie in Wirklichkeit aus mehreren Teilen, die jeweils eine bestimmte Funktion haben.

In Kombination leiten sie Ihre Software genau zu der Serverressource, auf die Sie zugreifen möchten. Bestimmte Komponenten geben den Dienst oder die Funktion an, die Sie aufrufen möchten, andere helfen bei der Identifizierung des Servers, mit dem Sie eine Verbindung herstellen möchten, und wieder andere enthalten weitere Informationen, die dem Server mitteilen, was Sie genau suchen.

Die Bestandteile einer URL arbeiten zusammen, damit Ihr Programm Informationen im Internet effektiv und genau finden und abrufen kann.

Jedes Teil hat einen besonderen Zweck und arbeitet mit den anderen zusammen. Dank dieser Komponenten weiß Ihre Software genau, wohin sie gehen und welche Informationen sie von einem Server anfordern muss.

Die wichtigsten Bestandteile einer URL sind:

• Protocol
• Domain
• Path
• Query string

Protocol

Da wir nun wissen, was eine URL ist und wofür sie steht, wollen wir im nächsten Schritt jede Komponente einzeln beschreiben. Das Protokoll ist der erste Teil jeder URL. Dies weist Ihren Browser oder Ihre MQL5-Anwendung an, wie sie sich mit einem Server verbinden soll. Das Protokoll legt, einfach ausgedrückt, die Richtlinien für den Datenfluss zwischen Ihrem Computer und dem Server fest, mit dem Sie eine Verbindung herstellen möchten.

Beispiel:

https://api.binance.com

Das Protokoll ist in diesem Fall https. Dies weist Ihr Programm an, das sichere „Hypertext Transfer Protocol“ zu verwenden. Die Arbeit mit sensiblen Daten, wie Handelsinformationen oder Kontodaten, ist sicherer, da HTTPS die gesendeten und empfangenen Daten verschlüsselt. HTTP und https unterscheiden sich darin, dass http die Daten nicht verschlüsselt. Sie überträgt lediglich Textdaten. Es ist schneller, aber weniger sicher. Da sie mit sensiblen und finanziellen Daten umgehen, müssen moderne APIs wie Binance https verwenden.

Analogie:

Stellen Sie sich vor, Sie haben jemandem eine wichtige Nachricht zu überbringen. Werden Sie die normale Post oder einen sicheren Zustelldienst nutzen? Jede Methode hat ihre eigenen Sicherheitsstandards. In ähnlicher Weise legt ein Protokoll fest, wie Ihre Software mit einem Server interagiert.

Dies ist vergleichbar mit der Auswahl eines sicheren Zustelldienstes, der das Abfangen von Nachrichten verhindert, wenn eine URL mit https beginnt. Wenn eine URL mit http beginnt, ist das so, als würde man einen ungeschützten Brief per Post verschicken. Da es garantiert, dass die Daten, die zwischen Ihrem Programm und dem Server übertragen werden, sicher gehandhabt werden, ist https für Binance und die Mehrheit der modernen APIs notwendig.

Domain

Die Domäne kommt nach dem Protokoll (https). Die Domäne weist Ihr Programm an, mit welchem Server es sich verbinden soll, um die gewünschten Daten zu erhalten. Er kann mit dem Namen der Struktur verglichen werden, in der die Daten gespeichert sind. Um Ihre Botschaft richtig zu vermitteln, benötigen Sie den genauen Gebäudenamen, auch wenn Sie die Straße oder den Ort kennen.

Beispiele:

https://api.binance.com
https://api.coingecko.com

Die Domäne kommt nach dem Protokoll, das Ihrer Software anzeigt, dass Sie eine Verbindung zu einem sicheren Server herstellen möchten. Die Domäne funktioniert ähnlich wie die Adresse des gewünschten Servers.

Die Domain (api.binance.com) leitet Ihr Programm an den entsprechenden Server weiter, während das Protokoll eine sichere Verbindung gewährleistet. Sie dienen als Eckpfeiler Ihrer API-Anfrage und sorgen dafür, dass Ihre Software sicher an ihrem Ziel ankommt.

Das Gleiche gilt für api.coingecko.com. Die Domain ist die Adresse des Servers, und das https garantiert eine sichere Verbindung. Dadurch wird verhindert, dass die von einem Server gesendeten oder angeforderten Daten mit Daten von einem anderen Server verwechselt werden.

Path

Der Pfad ist der nächste Teil einer URL, der auf das Protokoll und die Domäne folgt. Der Pfad zeigt Ihrem Programm an, auf welche bestimmte Serverfunktion oder Ressource Sie zugreifen möchten. Der Pfad verweist auf den genauen Ort oder Dienst innerhalb des Servers, während die Domain Ihre Software auf den entsprechenden Server verweist.

Beispiel:

https://api.binance.com/api/v3/ticker/price

Path ist /api/v3/ticker/price. Dieser Pfad verweist Ihre Software auf die Funktion, die den aktuellen Preis des Kryptowährungssymbols liefert. Ohne die Pfadangabe weiß der Server nicht, auf welche Informationen oder Funktionen Sie zugreifen möchten.

Betrachten Sie den Pfad als Stockwerk und Zimmernummer innerhalb des Gebäudes und den Bereich als das Gebäude selbst. Der Pfad gibt das genaue Stockwerk und den Raum an, in dem sich die Informationen befinden, während die Domain (z. B. api.binance.com) angibt, welches Gebäude zu besuchen ist.

Eine andere Analogie ist ein Pfad zu einer Datei auf Ihrem Computer:

C:\Users\Israel\Documents\CryptoData\prices.xlsx

Dies bezieht sich auf den Pfad zu einem bestimmten Dokument auf Ihrem Computer und den spezifischen Pfad, dem Sie folgen müssen. Das bedeutet, dass Sie mehrere Ordner öffnen müssen, um Zugriff auf die Datei zu erhalten.

APIs und Websites folgen häufig unterschiedlichen Wegen für verschiedene Zwecke. Jedem Pfad ist ein bestimmter Dienst oder Datensatz zugeordnet, z. B. die Abfrage der neuesten Kurse, historische Kerzendaten oder Kontoinformationen. Die meisten APIs bieten eine Dokumentationsseite mit einer Liste aller verfügbaren Pfade und einer Erläuterung der Funktionen und erforderlichen Parameter jedes Pfads. Dieser Leitfaden hilft Ihnen zu verstehen, wie Sie Anträge richtig stellen und die gewünschten Daten erhalten.

Verwenden wir diesen Pfad aus der Binance-API: /api/v3/ticker/price. Es ist vergleichbar mit dem Durchsuchen der Dateien auf Ihrem Computer, um eine bestimmte Datei zu finden.

• Zuerst geben Sie den Ordner api ein.
• Darin befindet sich der Ordner v3, der die Version der API darstellen kann.
• Dann öffnen Sie den Ordner ticker, der Dateien oder Funktionen im Zusammenhang mit Kryptowährungs-Tickern enthält.
• Schließlich gelangen Sie zum Preis, der die genaue Datei oder Ressource ist, die Ihnen den letzten Preis eines Symbols liefert.

Wenn Ihre Software diesen Pfad über die Domain api.binance.com erreicht, durchläuft sie Schritt für Schritt die Struktur des Servers, um genau die Funktion oder Information zu erhalten, die Sie angefordert haben. Aus diesem Grund ist jeder Abschnitt des Weges von Bedeutung. Ihr Programm kann an der falschen Stelle landen oder einen Fehler erhalten, wenn eine Komponente übersprungen oder falsch geschrieben wird.

Query String

Wir haben den Pfad als ähnlich dem Ordner auf einem Server beschrieben, in dem die Preise gespeichert sind. Der Pfad allein kann den gesamten Inhalt dieses Ordners liefern, aber Sie können ihn auch verwenden, um Daten aus diesem Ordner abzufragen. Sie können die gewünschten Daten genauer angeben, indem Sie die Abfragezeichenfolge verwenden.

Dies ist vergleichbar mit einem Ordner mit verschiedenen Dateien auf Ihrem Computer. Anstatt selbst nach einer bestimmten Datei zu suchen, können Sie die Abfragezeichenfolge verwenden, um anzugeben, welche Datei der Computer für Sie identifizieren soll.

Beispiel:

https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT

https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT ist die URL. Wir können sie in ihre einzelnen Bestandteile zerlegen. Das Protokoll https:// weist Ihre Anwendung an, eine sichere Verbindung mit dem Server herzustellen, sodass alle übertragenen und empfangenen Daten verschlüsselt werden. Die Domain api.binance.com weist Ihr Programm an, wohin es die Anfrage senden soll, und ist die Adresse des Servers, mit dem Sie sich verbinden möchten. Die URL /api/v3/ticker/price verweist den Server auf die Funktion, die den aktuellen Preis der Kryptowährung angibt.

Die Abfragezeichenfolge beginnt immer mit einem ?, und dies ist eher eine Mitteilung an den Server, dass Sie nach dem Hinzufügen des Pfads weitere Anweisungen geben müssen. Im Beispiel hätten wir nach dem Hinzufügen des Pfads einfach die Preise anfordern können, aber um genauer zu sein, haben wir das Fragezeichen hinzugefügt, das anzeigt, dass wir zusätzliche Anweisungen einfügen wollen. Danach fügten wir die Anweisung symbol=BTCUSDT hinzu, was bedeutet, dass wir den Preis für BTCUSDT genau wissen wollen.

Dieses Format kann verwendet werden, um verschiedene Informationen wie den aktuellen Preis oder Kerzendaten für einen bestimmten Zeitraum abzufragen. Sie müssen beachten, dass das Format der Abfragezeichenfolge für verschiedene Plattformen ähnlich ist, aber einige Schlüsselwörter sind meistens anders. Daher ist es wichtig, die API-Dokumentation der Plattform zu lesen, um ihr volles Potenzial zu nutzen.

Abrufen von aktuellen Preisen mit einer API in MQL5

Das Zusammenspiel von Protokoll, Domäne, Pfad und Abfragezeichenfolge sollte Ihnen inzwischen klar sein, da ich die Elemente einer URL im letzten Kapitel beschrieben habe. Sie kennen bereits die Grundlagen der Kommunikation von MQL5 mit externen Servern, da wir im vorherigen Artikel die Verwendung der Methode WebRequest und ihrer Parameter besprochen haben. Die Binance-API wird in diesem Abschnitt verwendet, um den aktuellen Preis eines Vermögenswertes zu erhalten. Das Konzept ist ganz einfach. Der Server stellt den aktuellsten Preis im JSON-Format bereit, nachdem Sie die entsprechende URL erstellt und Ihre Anfrage mit WebRequest übermittelt haben. Wir werden MQL5-Code entwickeln, um den zurückgegebenen Text zu durchsuchen und nur den erforderlichen Wert zu extrahieren, da die Antwort in JSON vorliegt.

Wir werden ein kleines MQL5-Skript erstellen, das die aktuellen Preise verschiedener Vermögenswerte abruft, um dies möglich zu machen. Das Skript stellt automatisch eine Verbindung zu Binance her und liefert den neuesten Preis, nachdem der Nutzer das Symbol der Kryptowährung eingegeben hat. Da Sie den Preis für BTCUSDT, ETHUSDT, BNBUSDT oder jedes andere Handelspaar, das Binance unterstützt, erfragen können, ist es vielseitig.

Die allgemeine Struktur dieses Verfahrens ist für jede externe API gleich. Die einzigen Unterschiede bestehen in den Definitionen des Pfads und des Abfrage-Strings, die von jeder Plattform verwendet werden. Daher ist es wichtig, die API-Dokumentation der Plattform zu studieren, mit der Sie sich verbinden möchten, damit Sie wissen, wie Sie Ihre Anfragen richtig vorbereiten.

Es ist wichtig, dass Sie externe Anfragen auf Ihrem MetaTrader 5 zulassen, wenn Sie Webanfragen über einen externen Server senden oder empfangen möchten. Dies ist wichtig, da MetaTrader 5 aus Sicherheitsgründen automatisch alle externen Abfragen blockiert. Gehen Sie auf Extras und dann auf Optionen, oder drücken Sie einfach Strg + O, um den Zugriff zu aktivieren. Wählen Sie anschließend unter der Registerkarte Expert Advisors die Option Allow WebRequest for listed URLs. Klicken Sie abschließend auf OK, nachdem Sie https://api.binance.com in die Liste der zulässigen URLs aufgenommen haben. Sobald diese Einrichtung abgeschlossen ist, kann Ihr Skript problemlos Abfragen an Binance senden.

Die Deklaration aller Variablen, die für die WebRequest-Funktion benötigt werden, ist der erste Schritt vor dem Absenden von Anfragen. Die URL, die Kopfzeilen, die zu sendenden Daten, der Antwortpuffer und der Ergebniscode werden in diesen Variablen gespeichert. Indem wir diese Variablen zu Beginn deklarieren, können wir die Organisation des Skripts beibehalten und sicherstellen, dass alles vorbereitet ist, bevor wir die eigentliche Anfrage an den Binance-Server senden.

Beispiel:

const string method = "GET";
const string url = "https://api.binance.com/api/v3/ticker/price";
const string headers = "";
int timeout = 5000;
char   data[];
char result[];
string result_headers;

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   WebRequest(method,url,headers,timeout,data,result,result_headers);

   Print(CharArrayToString(result));

  }

Ausgabe:

Result:

[

  {"symbol":"ETHBTC","price":"0.03313000"},

  {"symbol":"LTCBTC","price":"0.00107100"},

  {"symbol":"BNBBTC","price":"0.00974800"},

  {"symbol":"NEOBTC","price":"0.00005020"},

  {"symbol":"QTUMETH","price":"0.00055350"},

  {"symbol":"EOSETH","price":"0.00030670"},

  {"symbol":"SNTETH","price":"0.00001700"},

  {"symbol":"BNTETH","price":"0.00020260"},

  {"symbol":"BCCBTC","price":"0.00000000"},

  {"symbol":"GASBTC","price":"0.00002500"},

  {"symbol":"BNBETH","price":"0.29410000"},

  {"symbol":"BTCUSDT","price":"95566.46000000"},

  {"symbol":"E

Erläuterung:

const string method = "GET";

Die Methode „GET“ wird verwendet, um dem Server mitzuteilen, dass Sie Daten empfangen möchten.

const string url = "https://api.binance.com/api/v3/ticker/price";

Als Nächstes haben wir eine String-Variable definiert, um die URL zu speichern. Die URL enthält das Protokoll (https://), die Domäne (api.binance.com) und den Pfad (/api/v3/ticker/price). Die einzige Komponente der URL, die nicht enthalten war, war der Query-String, und das ist, weil kein zusätzlicher Befehl erforderlich war. Dies ist wichtig, wenn Sie die Parameter für die WebRequest-Funktion ausfüllen.

const string headers = "";
int timeout = 5000;
char   data[];

In diesem Codeblock haben wir drei Variablen deklariert. Der erste ist die Kopfzeile, die normalerweise zusätzliche Informationen enthält, die Sie zusammen mit Ihrer Anfrage an den Server senden möchten, aber in einem Fall wie diesem kann die Kopfzeile leer bleiben. Die Kopfzeile wurde nur deshalb aufgenommen, weil sie bei der Eingabe der WebRequest-Funktion benötigt wird. 

Mit dem Timeout wird die Zeitspanne in Millisekunden angegeben, die die Anfrage auf eine Antwort vom Server warten soll. Geht innerhalb der angegebenen Frist keine Antwort ein, wird die Anfrage gelöscht. Schließlich werden Daten verwendet, um zusätzliche Informationen aufzunehmen, die mit der Anfrage an den Server gesendet werden.

char result[]; 
string result_headers;

Nach Beendigung der WebRequest speichert der Server den Hauptteil der Antwort im Ergebnis-Array. Er speichert die Rohdaten, die der Server in der Regel in Form von Bytes zurückgibt, die dann für die weitere Verwendung in einen lesbaren Text umgewandelt werden können. Die Antwort auf diesen Binance-Endpunkt wird ein JSON-String mit verschiedenen Preisen für jedes Handelspaar sein. Alle HTTP-Antwort-Header, die der Server sendet, einschließlich Metadaten über die Antwort wie Inhaltstyp, Inhaltslänge, Serverinformationen und alle zusätzlichen Anweisungen oder Informationen, die der Server zusammen mit den Daten liefert, werden in der Ergebnis-Header-Zeichenkette erfasst.

int web_request =  WebRequest(method,url,headers,timeout,data,result,result_headers);
Print(CharArrayToString(result));

Die Funktion WebRequest wurde verwendet, um eine „GET“-Anfrage an den Server zu senden. Wir geben alle notwendigen Parameter der Funktion ein: Methode, URL, Kopfzeilen, Timeout, Ergebnis und die Ergebniskopfzeile. Die Funktion wartet, bis sie eine Antwort vom Server erhält. Nach einer erfolgreichen Antwort wird diese in der Ergebnisvariablen gespeichert.

Da Arrays von Einzelzeichen im Expertenprotokoll nicht direkt gelesen werden können, werden die rohen Bytes im Ergebnis-Array nach Erhalt der Antwort in eine lesbare Zeichenkette umgewandelt, damit sie problemlos geschrieben und interpretiert werden können. Die Zeichenkette, die sich aus dieser Binance-Anfrage ergibt, ist JSON und enthält die aktuellen Preise mehrerer Handelspaare.

Wir müssen zunächst die genaue Anordnung der JSON-Struktur studieren, um sie zu filtern und die gewünschten Informationen zu erhalten. JSON kann von jeder Plattform oder API anders angeordnet werden, mit Unterschieden in Array-Strukturen, Verschachtelung und Feldnamen. Neben der Vermeidung von Fehlern, die entstehen können, wenn wir von einer Struktur ausgehen, die nicht mit der realen Reaktion übereinstimmt, ermöglicht uns die Kenntnis des genauen Musters, die notwendigen Informationen, wie z. B. bestimmte Handelspaarungen oder Kurswerte, genau zu extrahieren. Das Ergebnis ist einfach ein sich wiederholendes Muster von Preisen für verschiedene Symbole, wenn wir es ausdrucken, was es einfacher macht, die genauen Informationen, die wir brauchen, zu finden und zu extrahieren.

Beispiel:

[

  {"symbol":"ETHBTC","price":"0.03313000"},

  {"symbol":"LTCBTC","price":"0.00107100"},

  {"symbol":"BNBBTC","price":"0.00974800"},

  {"symbol":"NEOBTC","price":"0.00005020"},

  {"symbol":"QTUMETH","price":"0.00055350"},

Jeder Preis wird auf die gleiche Weise formatiert, beginnend mit "symbol", INSTRUMENT, "price": wobei INSTRUMENT für das Handelspaar steht und der Preis den nachfolgenden Wert darstellt. Diese regelmäßige Struktur ermöglicht es uns, das JSON sorgfältig zu untersuchen und die relevanten Preise und Symbole zu extrahieren.

Beispiel:

const string method = "GET";
const string url = "https://api.binance.com/api/v3/ticker/price";
const string headers = "";
int timeout = 5000;
char   data[];
char result[];
string result_headers;

string instrument = "BTCUSDT";

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int web_request =  WebRequest(method,url,headers,timeout,data,result,result_headers);

// Print(CharArrayToString(result));

   string pattern = "{\"symbol\":\"" + instrument + "\",\"price\":\"";
   string jason = CharArrayToString(result);

   int pattern_lenght = StringFind(jason,pattern);
   pattern_lenght += StringLen(pattern);

   int end = StringFind(jason,"\"",pattern_lenght + 1);

   string coin_price = StringSubstr(jason,pattern_lenght,end - pattern_lenght);

   Print(instrument,": ", coin_price);

  }

Ausgabe:

Erläuterung:

string instrument = "BTCUSDT";
string pattern = "{\"symbol\":\"" + instrument + "\",\"price\":\"";

Wir haben eine Variable definiert, um das Symbol für das Instrument, mit dem wir arbeiten möchten, zu speichern. In der zweiten Zeile werden die Instrumentenvariable und der Text kombiniert, um das JSON-Suchmuster zu erstellen. Damit der Computer den richtigen Preis finden kann, muss die gleiche Struktur wie in der JSON-Antwort von Binance erstellt werden. Die Endausgabe entspricht dem, was die API liefert, indem die Variable mit dem festen Teil des JSON zusammengeführt wird.

Um eine Zeichenkette in MQL5 zu beginnen und zu beenden, verwenden Sie Anführungszeichen. Der Compiler würde davon ausgehen, dass die Zeichenkette zu Ende ist, wenn Sie innerhalb der Zeichenkette ein Anführungszeichen eingeben würden. Um dies zu beheben, verwenden Sie einen Backslash, um das Anführungszeichen zu umgehen. So wird MQL5 angewiesen, das Anführungszeichen " als reguläres Zeichen innerhalb der Zeichenkette und nicht als Zeichen für das Ende der Zeichenkette zu behandeln.

Dies ist erforderlich, weil der Instrumentenname, der Preis und das Symbol im JSON-Format selbst von Anführungszeichen umgeben sind. Ohne Escaping würde die Anwendung nicht richtig mit dem von der API vorgegebenen JSON-Format übereinstimmen, und das Muster würde abbrechen oder zu einem Syntaxfehler führen.

string jason = CharArrayToString(result);

Diese Zeile erstellt eine lesbare Zeichenkette aus der Rohantwort der WebRequest und speichert sie in einer neuen Variablen. Es ist nicht möglich, Informationen direkt aus der WebRequest-Methode zu suchen oder zu extrahieren, da sie ihre Daten als Zeichenarray zurückgibt. Sie können mit den Daten arbeiten, indem Sie Standard-String-Operationen wie Suchen, Teilstring und Vergleichen verwenden, indem Sie das Array in einen String umwandeln. Dieser übersetzte Text wird nur in der neuen Variable gespeichert, damit er in den nachfolgenden Phasen bearbeitet werden kann.

int pattern_lenght = StringFind(jason,pattern);

In dieser Zeile wird der Anfang des Musters in der gesamten JSON-Zeichenkette gefunden, und wir verwenden diese Stelle, um herauszufinden, wie viele Zeichen vor dem Beginn des Musters kommen. Nachdem die Funktion die gesamte JSON-Antwort untersucht hat, gibt sie den Index des ersten Zeichens im Muster zurück. Wenn Sie zum Beispiel nach „BEGINNERS“ im Text „MQL5 FOR BEGINNERS“ suchen, gibt die Funktion 9 zurück. Ein Index in MQL5 ist einfach die numerische Position eines Zeichens innerhalb einer Zeichenkette. Dieser zurückgegebene Index gibt genau an, wo das Muster innerhalb des JSON beginnt, sodass wir später den richtigen Preiswert abrufen können.

pattern_lenght += StringLen(pattern);

Durch Addition der Länge des Musters erhöht diese Zeile die Ausgangsposition. Die Methode StringLen wird verwendet, um die Anzahl der Zeichen im Muster selbst zu zählen, nachdem wir den Index des ersten Zeichens des Musters innerhalb des JSON gefunden haben. Wir wollen den Mustertext nicht in die endgültige Extraktion einbeziehen; daher ist dieser Schritt entscheidend. Wir bewegen den Zeiger vorwärts, bis er genau auf dem ersten Zeichen des Preiswerts ankommt, indem wir die Länge des Musters zum Startindex addieren. Dadurch wird alles eliminiert, was vorher kommt, einschließlich des Musters selbst. Damit ist sichergestellt, dass wir nur den Preis herausholen.

int end = StringFind(jason,"\"",pattern_lenght + 1);

Die Funktion funktioniert, sobald wir den genauen Beginn des Preiswertes sowie die Länge des Musters festgelegt haben. Der nächste Schritt besteht darin, das Ende dieser Preisgestaltung zu bestimmen. Zu diesem Zweck verwenden wir die dreiparametrige Funktion StringFind. Der in Jason gespeicherte JSON-Text ist die primäre Zeichenfolge, die wir durchsuchen wollen, und er ist der erste Parameter.

Der zweite Parameter ist das Zeichen, nach dem wir suchen, in diesem Fall das Anführungszeichen ", da der Preiswert in JSON immer von Anführungszeichen umgeben ist. Der dritte Parameter teilt StringFind mit, wo die Suche beginnen soll. Mit pattern_lenght + 1 weisen wir das Programm an, mit der Suche zu beginnen, sobald das Muster endet, also genau dort, wo die Kursziffern beginnen.

Dies ist wichtig, weil in der JSON-Struktur, wie

{"symbol":"ETHBTC","price":"0.03313000"},

{"symbol":"LTCBTC","price":"0.00107100"},

Das Muster ist dieser Teil: {"symbol":"LTCBTC","price":". Der Preiswert folgt, und das endgültige Angebot erscheint direkt nach dem Preis. Um die letzte Phrase zu finden, beginnen wir unsere Suche direkt nach dem Muster. Auf diese Weise können wir den Preis genau ermitteln, da wir den genauen Endindex erhalten.

string coin_price = StringSubstr(jason,pattern_lenght ,end - pattern_lenght);
Print(instrument,": ", coin_price);

Nachdem wir festgestellt haben, wo das Muster beginnt und wo die Schlussnotierung erscheint, ist dieser Teil des Codes für das Abrufen des tatsächlichen Preisbetrags verantwortlich.

Hier wird nur der Preis mit Hilfe der Funktion StringSubstr extrahiert, mit der ein bestimmter Abschnitt einer Zeichenkette abgeschnitten wird. Der vollständige JSON, der in der Variablen jason enthalten ist, ist der erste Parameter, der die Funktion anweist, welchen Text wir ausschneiden möchten. Da pattern_lenght bereits auf das erste Zeichen des Preises vorgerückt wurde, gibt das zweite Argument die genaue Stelle an, an der der Preis beginnt, nämlich den in pattern_lenght gespeicherten Wert.

Der dritte Parameter gibt der Funktion die Anzahl der zu extrahierenden Zeichen vor. Wir subtrahieren pattern_lenght von Ende, um diese Länge zu berechnen, indem wir den Anfangspunkt vom Endpunkt subtrahieren. Ohne Anführungszeichen oder andere Symbole erhalten wir so die genaue Anzahl der Buchstaben, aus denen sich der Preiswert zusammensetzt.

Nach Abschluss der Extraktion wird das Ergebnis in coin_price gespeichert, das nur den reinen Preis enthält, z. B. 0,03313000. Die Print-Anweisung schließlich macht das Ergebnis leicht lesbar, indem sie sowohl den Instrumentennamen als auch den extrahierten Preis im Protokoll anzeigt. Alles, was Sie jetzt tun müssen, ist das Symbol einzugeben, um den Preis für jeden beliebigen Vermögenswert auf der Plattform zu finden. Das System ist anpassungsfähig und kann mit jedem von Ihnen ausgewählten Vermögenswert umgehen, da die gleiche Logik automatisch das JSON durchsucht, das entsprechende Muster findet, den Preis extrahiert und anzeigt.

Es ist wichtig, daran zu denken, dass jede Website eine Obergrenze für die Anzahl der Anfragen hat, die Sie innerhalb eines bestimmten Zeitraums stellen können. Aus diesem Grund ist es nicht ratsam, diese Methode direkt in der OnTick-Funktion eines EAs zu verwenden, da sie das Abfragelimit schnell überschreiten kann. Um zu gewährleisten, dass Sie die zulässige Abrufrate der Plattform nicht überschreiten, müssen Sie jedoch eine Zeitspanne zwischen den einzelnen Abrufen einplanen, wenn Sie einen triftigen Grund haben.

Zum besseren Verständnis können wir die Preise über eine andere Plattform ermitteln; verwenden wir dieses Mal CoinGecko. Darüber hinaus bietet CoinGecko eine öffentliche API, die JSON-Daten für viele Kryptowährungen liefert. Das Verfahren ist im Wesentlichen dasselbe: Sie machen einen HTTP-Aufruf an den API-Endpunkt, erhalten eine JSON-Antwort und extrahieren dann den Preis des Assets, das Sie interessiert.

Beispiel:

const string method = "GET";
//const string url = "https://api.binance.com/api/v3/ticker/price";
const string url = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum&vs_currencies=usd";

const string headers = "";
int timeout = 5000;
char   data[];
char result[];
string result_headers;

string instrument = "ETHUSDT";

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int web_request =  WebRequest(method,url,headers,timeout,data,result,result_headers);

   Print(CharArrayToString(result));


  }

Ausgabe:

{"bitcoin":{"usd":95566},"ethereum":{"usd":3169.35}}}

Erläuterung:

Wir ändern die URL in diejenige, die für die Abfrage des aktuellen Preises bei Verwendung der CoinGecko-API verwendet wird. Dieses Mal haben wir einen Query-String hinzugefügt, der von CoinGecko benötigt wird, um anzugeben, für welche Münzen und welche Währungen wir Preise haben wollen. Der Basisendpunkt und die Parameter werden durch ein Fragezeichen (?) am Anfang der Abfragezeichenfolge getrennt. In diesem Fall gibt vs_currencies=usd an, dass wir die Preise in US-Dollar haben wollen, und ?ids=bitcoin,ethereum weist CoinGecko an, für welche Kryptowährungen wir Werte haben wollen. Wir verwenden ein &, um mehrere Parameter zu trennen, wie in diesem Beispiel. Für jedes Argument wird das Format Schlüssel=Wert verwendet.

Daher ist es die allgemeine Richtlinie, ein & zu verwenden, um mehrere Schlüssel-Wert-Paare innerhalb der Abfragezeichenfolge zu unterteilen und ein ?, um den Abfrage-String nach der Basis-URL zu beginnen. Dadurch weiß der Server genau, welche Informationen Sie abfragen. Sie werden sehen, dass sich das JSON-Muster von CoinGecko von dem von Binance unterscheidet, nachdem Sie das Ergebnis ausgedruckt haben. Dies zeigt, wie wichtig es ist, zunächst die Antwort zu prüfen und die Struktur des JSON zu verstehen. Da jede Plattform ihre Antwort anders formatiert, können Sie mit der Kenntnis des genauen Musters die benötigten Daten, z. B. den Preis einer bestimmten Münze, fehlerfrei extrahieren.

Um die Ausgabe von WebRequest zu ermöglichen, müssen Sie die CoinGecko API URL zu Ihren MetaTrader 5 Einstellungen hinzufügen. Das Hinzufügen der API zur Liste der erlaubten URLs garantiert, dass Ihr Skript oder EA sich erfolgreich mit CoinGecko verbinden und die Daten abrufen kann, da MetaTrader 5 standardmäßig Aufrufe zu externen URLs blockiert.

https://api.coingecko.com

Beispiel:

const string method = "GET";
//const string url = "https://api.binance.com/api/v3/ticker/price";
const string url = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum&vs_currencies=usd";

const string headers = "";
int timeout = 5000;
char   data[];
char result[];
string result_headers;

string instrument = "bitcoin";

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int web_request =  WebRequest(method,url,headers,timeout,data,result,result_headers);

// Print(CharArrayToString(result));

   string pattern = "{\"" + instrument + "\":{\"usd\":";
   string jason = CharArrayToString(result);

   int pattern_lenght = StringFind(jason,pattern);
   pattern_lenght += StringLen(pattern);

   int end = StringFind(jason,"}",pattern_lenght + 1);

   string coin_price = StringSubstr(jason,pattern_lenght,end - pattern_lenght);

   Print(instrument,": ", coin_price);

  }

Ausgabe:

Erläuterung:

Es wurden nur zwei Änderungen vorgenommen. Zunächst haben wir sichergestellt, dass die URL mit der API der Plattform übereinstimmt. Da das JSON-Format für verschiedene Plattformen unterschiedlich sein kann, haben wir sichergestellt, dass es dasselbe ist wie bei GoinGecko.

Schlussfolgerung

In diesem Artikel haben Sie gelernt, wie Sie die WebRequest-Funktion von MQL5 und die APIs externer Plattformen nutzen können, um Preisdaten in Echtzeit zu erhalten. Darüber hinaus haben Sie nun ein umfassendes Verständnis für das Protokoll, die Domäne, den Pfad und die Abfrage einer URL. Schließlich haben Sie herausgefunden, wie Sie bestimmte Informationen aus JSON-Antworten extrahieren und kategorisieren können, um unverarbeitete API-Daten in aufschlussreiches Wissen zu verwandeln.