In diesem umfassenden Leitfaden behandeln wir die Grundlagen zur Programmierung eines Forex-Trading-Robots sowie die Sprachen MQL4 und MQL5.

Mit einem Trading-Roboter lassen sich am Forex-Markt zahlreiche Aufgaben umsetzen. Der häufigste Einsatzzweck ist die Automatisierung von Handelsstrategien. In diesem Artikel behandeln wir die Grundlagen der Programmierung eines Forex-Trading-Roboters. Zunächst beantworten wir die Frage: „Welche Arten von Programmen lassen sich mit MQL4/MQL5 entwickeln?“
Welche Arten von Code können in MQL4/MQL5 programmiert werden?
Die hier vorgestellten Beispiele basieren auf den Programmiersprachen MQL4 und MQL5. In MQL4/MQL5 lassen sich drei verschiedene Arten von Programmen erstellen:
- Expert Advisors (Forex-Roboter)
- Benutzerdefinierte Indikatoren
- Skripte
1. Der Expert Advisor (EA)
Er stellt die Automatisierung eines manuellen Handelssystems dar und wird direkt auf den Chart eines ausgewählten Finanzinstruments angewendet. Mit anderen Worten: Jeder Code für einen EA muss stets im Kontext des jeweiligen Charts entwickelt werden.
Einige dieser Ereignisse werden nur einmal ausgeführt, andere laufen fortlaufend, bis sie ein Stoppsignal erhalten. Ein EA nimmt seine Arbeit auf, sobald die Ereignisse der Initialisierungssequenz (init) ausgelöst werden.
Zu diesen Ereignissen gehören ein neues Preisniveau bzw. ein neuer Tick, ein Chart-Ereignis oder benutzerdefinierte Events. Sobald diese Ereignisse eintreten, sendet der EA eine Order an den Server des Brokers, um eine Position zu eröffnen oder zu schließen. EA-Dateien werden im Ordner MQL4/Experts des MT4-Clients gespeichert.
2. Das Skript
Ein Skript dient dazu, bestimmte Funktionen einmalig auszuführen, wie etwa beim Start-Ereignis. Skriptdateien werden im Ordner MQL4/scripts des MT4-Clients gespeichert.
3. Der benutzerdefinierte Indikator
Dabei handelt es sich um einen maßgeschneiderten technischen Indikator, der nicht zu den Standardindikatoren von MT4 gehört. Indikatoren platzieren selbst keine Trades, sondern dienen dazu, chartbasierte Signale zu identifizieren, die wiederum manuelle Trades oder EA-Aktivitäten auslösen können. Benutzerdefinierte Indikatoren werden im Ordner MQL4/indicators des MT4-Clients abgelegt.
So erstellen Sie einen Forex-Roboter mit MQL4/MQL5
Der Code für einen Forex-Trading-Roboter, Indikator oder ein Skript unter MQL4/MQL5 basiert im Wesentlichen auf vier Elementen: Syntax, Variablen, Ausdrücke und Bedingungen. Im Folgenden sehen wir uns an, wie Sie Ihren Roboter anhand dieser vier Grundlagen aufbauen:
Im weiteren Verlauf dieses Artikels beziehen wir uns in erster Linie auf MQL4. Die erläuterten Prinzipien gelten jedoch gleichermaßen für MQL5.
1. Machen Sie sich mit der Syntax vertraut
Die Syntax einer Programmiersprache umfasst die Regeln und Richtlinien, die bestimmen, wie Code geschrieben und strukturiert sein muss.
Die fehlerfreie Kompilierung und Ausführung des Codes eines Forex-Roboters setzt voraus, dass die Syntax korrekt ist und exakt den Regeln der jeweiligen Sprache entspricht, mit der Sie den Expert Advisor, das Skript oder den Indikator entwickeln.
Hier sind die wichtigsten Bestandteile der MQL4-Syntax:
- Kommentare: Textzeilen im Programm, die vom Compiler ignoriert werden. Entwickler nutzen sie, um den Code für sich und andere verständlich zu dokumentieren. Mehrzeilige Kommentare werden von /* und */ umschlossen, einzeilige Kommentare beginnen mit //.
- Variablen: Benannte Speicherplätze im Arbeitsspeicher, die Daten aufnehmen. Der Wert einer Variable kann sich während der Programmausführung ändern.
- Datentypen: Klassifizierungen, die festlegen, welche Art von Wert eine Variable speichern kann. Beispiele sind
int(Ganzzahlen),double(Gleitkommazahlen für Kurse),bool(wahr/falsch),string(Text),datetime(Datum und Uhrzeit) sowiecolor. - Bezeichner (Identifiers): Namen für Variablen, Funktionen, Klassen oder Module im Programm. Sie müssen mit einem Buchstaben oder einem Unterstrich beginnen, dürfen Buchstaben, Ziffern und Unterstriche enthalten und maximal 63 Zeichen lang sein. Zudem dürfen sie keine reservierten MQL4-Schlüsselwörter sein.
- Operatoren: Symbole, die Operationen mit einem oder mehreren Operanden (Werten oder Variablen) durchführen. Sie dienen arithmetischen, Vergleichs-, logischen oder Zuweisungsoperationen. Beispiele sind +, -, =, !=, || und &&.
- Bedingte Anweisungen: Sie steuern den Programmablauf und führen je nachdem, ob eine Bedingung wahr oder falsch ist, unterschiedliche Codeblöcke aus. Beispiele sind „if“-, „else if“- und „else“-Anweisungen.
- Schleifen: Sie steuern den Ablauf, indem sie einen Codeblock so lange wiederholen, wie eine bestimmte Bedingung erfüllt ist. Schleifen werden verwendet, um Datensätze zu durchlaufen oder wiederkehrende Aufgaben auszuführen. Beispiele sind „for“-, „while“- und „do-while“-Schleifen.
- Funktionen: Abgeschlossene Codeblöcke, die eine bestimmte Aufgabe erfüllen. Funktionen unterteilen Programme in kleinere Einheiten, was den Code lesbarer macht und Redundanzen vermeidet.
Wie Sie sehen, bietet die MQL4-Entwicklungsumgebung alle nötigen Syntaxelemente, um robuste Forex-Trading-Bots und Indikatoren zu programmieren.
2. Deklaration und Initialisierung
Variablen sind die Grundbausteine Ihres Codes. Bevor Sie eine Variable verwenden können, müssen Sie sie anlegen. Dieser Vorgang wird als Deklaration bezeichnet. In der Praxis werden die Begriffe „erstellen“ und „deklarieren“ oft synonym verwendet, in der Programmierung spricht man jedoch üblicherweise von Deklaration. Beim Deklarieren weisen Sie der Variablen einen bestimmten Datentyp zu.
Um eine Variable zu deklarieren:
- geben Sie den Datentyp gefolgt von einem Leerzeichen an,
- geben Sie den Variablennamen ein,
- schließen Sie die Zeile mit einem Semikolon (;) ab.
Hier sehen Sie, wie eine Variable mit dem Datentyp Integer (int) deklariert wird:

- Der Datentyp ist hier int für Integer (Ganzzahl).
- Der Variablenname lautet hi.
- Die Zeile wird mit einem Semikolon abgeschlossen.
Variablen werden mit verschiedenen Datentypen definiert (wie int für Ganzzahlen oder double für Gleitkommazahlen), gefolgt von einem Namen für die Variable (Bezeichner). Gängige Datentypen sind:
- Integer (int): Steht für ganze Zahlen im Bereich von rund -2 Milliarden bis +2 Milliarden. Der Datentyp int kann keine Nachkommastellen speichern.
- Double: Steht für Gleitkommazahlen im Bereich von -1,79 × 10308 bis +1,79 × 10308. Mit double lassen sich Werte mit Nachkommastellen erfassen.
- Boolean (Bool): Repräsentiert logische Werte, also wahr (true) oder falsch (false).
- Color: Speichert Farbwerte.
- String: Eine Zeichenkette bzw. ein Text.
- DateTime: Speichert Datum und Uhrzeit.
Angenommen, Sie haben die Variablen x, y und z mit den Ganzzahlen 10, 7 und 5. Sie möchten nun eine neue Variable a definieren und schreiben: a = y + z. Da die Werte von y und z bekannt sind, ergibt sich für a der Wert 12.
Um beispielsweise eine Integer-Variable namens „myVar“ zu deklarieren, nutzen Sie folgende Syntax:
int myVar
Sie können einer Variablen auch direkt bei der Deklaration einen Wert zuweisen. Angenommen, der zugewiesene Wert soll 12 sein. Dann verwenden Sie für die Integer-Variable myVar folgende Syntax:
int myVar = 10;
Nachdem eine Variable deklariert wurde, kann sie im MQL-Code für verschiedene Berechnungen genutzt werden oder Daten speichern. Wenn Sie nun die neue Variable a als Summe der Variablen y + z definieren möchten, sieht der Code beispielsweise so aus:
int var1 = 10;
int var2 = 7;
Int var3 = 5
int result = var2 + var3; // result = 12

In diesem Beispiel haben Sie drei Integer-Variablen deklariert: var1, var2 und var3 (entsprechend x, y und z). Diesen wurden die Werte 10, 7 und 5 zugewiesen. Um var2 und var3 zu addieren, verwenden Sie das Pluszeichen (+) als Operator; das Ergebnis wird in der neuen Variablen result gespeichert. Der Wert beträgt 12 – die Summe aus var2 und var3.
Im Trading-Alltag besteht eine wesentliche Aufgabe von Variablen darin, Werte zu speichern, die sich im Zeitverlauf ändern – wie etwa der Kurs eines Vermögenswerts. Da Währungskurse ständig schwanken, nutzen Sie Variablen, um diesen Wert bei jedem neuen Tick zu erfassen und zu aktualisieren.
double price;
price = SymbolInfoDouble(_Symbol, SYMBOL_BID); // get the current bid price
ol, SYMBOL_BID); // get the current bid price
In einem dynamischen Markt wie dem Forex-Markt sind Variablen im Code der Strategie Ihres Forex-Trading-Roboters unerlässlich, um Marktveränderungen in Echtzeit abzubilden und darauf zu reagieren.
3. Ausdrücke
Operationen basieren auf Rechenarten wie Addition, Subtraktion, Multiplikation und Division. Die entsprechenden Symbole werden als Operatoren bezeichnet. In Kombination mit Variablen bilden sie innerhalb einer Codezeile Ausdrücke (Expressions).
Hier sind die gängigsten Operatoren im MQL4-Code:
a) Arithmetische Operatoren: Plus, Minus, Modulo (Prozent), Division, Multiplikation (+ – % / *)
b) Logische Operatoren: && ||
c) Zuweisungsoperatoren: Gleich, Plus-Gleich, Multiplikation-Gleich (= += *=)
Wird ein Ausdruck mit einem Semikolon (;) abgeschlossen, bildet er eine vollständige Anweisung. Doch welche Ausdrücke sind für MQL4-Entwickler besonders wichtig?
Arithmetische Operatoren dienen dazu, mathematische Berechnungen mit Zahlenwerten durchzuführen. So sehen arithmetische Operatoren im Code aus:

Der Operator ++ weist das Programm an, den Wert von b in Zeile 27 um 1 zu erhöhen: Hat b den Wert 70, weist der Code bei b++ den Wert 71 zu. Analog verringert der Operator -- den Wert von b in Zeile 28 um 1, sodass b-- den Wert 69 ergibt.
Hier ist ein weiteres Beispiel für den Einsatz arithmetischer Operatoren:

Die Anweisung ‚#include <math.mqh>‘ bindet die mathematische Funktionsbibliothek ein, damit der Code fehlerfrei kompiliert werden kann. Die hier genutzten Funktionen der Math-Bibliothek sind MathPow() und MathSqrt().
Was bedeuten die einzelnen arithmetischen Operatoren im Detail?
- Addition (+): Addiert die Zahlenwerte links und rechts des Operators.
- Subtraktion (-): Subtrahiert den Wert rechts vom Operator vom Wert links des Operators.
- Multiplikation (*): Multipliziert die Werte links und rechts des Operators miteinander.
- Division (/): Teilt den Wert links des Operators durch den Wert rechts des Operators.
- Modulo (%): Gibt den Rest der ganzzahligen Division des linken Wertes durch den rechten Wert zurück.
So sieht die Anwendung in der MQL4-Entwicklungsumgebung aus:

10 lässt sich exakt zweimal ohne Rest durch 5 teilen; daher ergibt 10 % 5 in Zeile 23 den Wert 0.
Zuweisungsoperatoren dienen dazu, einer Variablen einen Wert zuzuweisen. Hier ist die Bedeutung der verschiedenen Zuweisungsoperatoren (= += -= *=):
- Zuweisung (=): Weist den Wert rechts des Operators der Variablen links des Operators zu.
- Additionszuweisung (+=): Addiert den rechten Wert zum aktuellen Wert der linken Variablen und speichert das Ergebnis wieder in der linken Variablen.
- Subtraktionszuweisung (-=): Subtrahiert den rechten Wert vom aktuellen Wert der linken Variablen und speichert das Ergebnis in der linken Variablen.
- Multiplikationszuweisung (*=): Multipliziert den aktuellen Wert der linken Variablen mit dem rechten Wert und speichert das Ergebnis in der linken Variablen.
- Divisionszuweisung (/=): Teilt den Wert der linken Variablen durch den rechten Wert und weist das Ergebnis der linken Variablen zu.
- Modulo-Zuweisung (%=): Berechnet den Divisionsrest aus dem Wert der linken Variablen geteilt durch den rechten Wert und weist das Ergebnis der linken Variablen zu.
Hier sehen Sie Beispiele für den Einsatz von Zuweisungsoperatoren in MQL4:

4. Bedingte Anweisungen und Operatoren (if/else, switch)
Bedingte Anweisungen führen bestimmte Aktionen nur dann aus, wenn vorgegebene Kriterien erfüllt sind. Sie ermöglichen es somit, eine Aktion daran zu koppeln, ob eine Bedingung wahr ist.
In MT4 werden hierfür vor allem „if-else“- und „switch“-Anweisungen verwendet. Beide steuern die bedingte Ausführung von Codeblöcken.
Die if-else-Anweisung
Die „if-else“-Anweisung kommt typischerweise zum Einsatz, wenn im Code mehrere Bedingungen nacheinander geprüft werden sollen:

Wird dieses Skript kompiliert und ausgeführt, gibt es 10 aus, da die Bedingung erfüllt ist. Wenn unter dieser Bedingung mehrere Anweisungen ausgeführt werden sollen, fassen Sie diese in geschweiften Klammern zusammen.
Im Trading-Kontext wird die if-else-Anweisung häufig verwendet, um Kursvariablen abzufragen und entsprechende Aktionen einzuleiten.
Hier ist ein Beispiel für die Funktionsweise einer if-else-Bedingung: Die Variable „price“ übernimmt standardmäßig den aktuellen Briefkurs (Ask). Der „if“-Teil prüft, ob der Kurs über 1,0 liegt. Falls ja, wird ausschließlich der Code im ersten geschweiften Klammernpaar ausgeführt. Trifft dies nicht zu (Kurs <= 1,0), wird der Code im nächsten Block ausgeführt.
//+--------------------------------------------------------+
//| Script program start function |
//+--------------------------------------------------------+
void OnStart(){
double price = Bid;
if (price > 1.0) {
// Execute this code if price is greater than 1.0
Alert("Price is above 1.0");
}else if (price < 0.5) {
// Execute this code if price is less than 0.5
Alert("Price is below 0.5");
}else {
// Execute this code if price is between 0.5 and 1.0
Alert("Price is between 0.5 and 1.0");
}
}

Sie können eine „if-else“-Anweisung auch innerhalb einer bestehenden Bedingung einbetten – also innerhalb der geschweiften Klammern des „if“- oder „else“-Blocks. Man spricht dann von einer geschachtelten if-else-Anweisung. Hier ein Beispiel:

Die geschachtelte if-else-Anweisung veranlasst das Programm zu prüfen, ob der Kurs < 0,8 ist oder zwischen 0,8 und dem Zielwert liegt. Liegt der Kurs unter 0,8, wird der Code im inneren if-Block ausgeführt. Andernfalls greift der innere else-Zweig.
Bedingte Anweisungen lassen sich beim Trading gezielt für Pending-Orders sowie für Ein- und Ausstiege nutzen – etwa Buy-Limit-, Sell-Limit-, Buy-Stop- und Sell-Stop-Orders sowie Take-Profit- und Stop-Loss-Marken. Diese Orders werden erst ausgeführt, wenn bestimmte Kursparameter erreicht sind (Bedingung). Werden die Bedingungen nicht erfüllt, erfolgt keine Ausführung. So formulieren Sie den Code für bedingte Einstiege in MQL4:
Buy Stop
Um eine Buy-Stop-Order auf einem bestimmten Kursniveau zu platzieren, können Sie folgenden Code verwenden. Dieser weist den Forex-Trading-Roboter an, Folgendes auszuführen:
– eine BUY-STOP-Order mit einem Abstand von 10 Pips zum aktuellen Kurs und einem Limit-Abstand von 20 Pips zu platzieren,
– als Positionsgröße 1 Standard-Lot (1,0 Lot) zu verwenden,
– das Einstiegsniveau zur besseren Übersicht mit einer grünen Linie im Chart zu markieren,
– diesem Trade eine eindeutige Kennnummer (MagicNumber) zuzuweisen.
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
//---
double StopDistance = 10.0; // Stop distance in pips
double LimitDistance = 20.0; // Limit distance in pips
double Lots = 1.0; // Lot size
int Slippage = 3; // Maximum price deviation
int MagicNumber = 12345; // Unique identifier
color Green = Lime; // Order line color
// Get the current ask price
double price = Ask;
// Calculate the stop and limit prices
double stopPrice = NormalizeDouble(price + StopDistance * Point, Digits);
double limitPrice = NormalizeDouble(price + LimitDistance * Point, Digits);
// Place the buy stop order
int ticket = OrderSend(Symbol(), OP_BUYSTOP, Lots, stopPrice, Slippage, limitPrice, 0, "", MagicNumber, 0, Green);
if(ticket > 0)
{
Print("Buy stop order placed successfully with ticket #", ticket);
}
else
{
Print("Error placing buy stop order. Error code:", GetLastError());
}
}

Der Code definiert folgende Variablen:
- StopDistance
- LimitDistance
- Lots
- Slippage
- MagicNumber
- Green
Sobald die Order übermittelt wurde, prüft der Code anhand des Rückgabewerts der Funktion OrderSend() (Ticket), ob die Platzierung erfolgreich war. Wurde die Buy-Stop-Order erfolgreich platziert, gibt der Code eine Meldung im Journal-Reiter von MT4 aus. Andernfalls wird eine Fehlermeldung samt Fehlercode protokolliert.
Sell Limit
Um eine Sell-Limit-Order auf einem bestimmten Kursniveau zu platzieren, eignet sich folgender Code:
// Define order parameters
double lotSize = 0.1; // Lot size
double limitPrice = 1.2000; // Limit price
double stopLoss = 1.2100; // Stop loss
double takeProfit = 1.1900; // Take profit
int slippage = 3; // Maximum deviation in pips from the requested price
// Place sell limit order
bool sellLimitOrderPlaced = false;
int ticket = 0;
while (!sellLimitOrderPlaced) {
ticket = OrderSend(Symbol(), OP_SELLLIMIT, lotSize, limitPrice, slippage, stopLoss, takeProfit, "Sell Limit", MagicNumber, 0, Red);
if (ticket > 0) {
sellLimitOrderPlaced = true;
} else {
Print("Sell limit order failed with error code ", GetLastError());
Sleep(5000); // Wait for 5 seconds before retrying
}
}
// Check if the order is still open
while (OrderSelect(ticket, SELECT_BY_TICKET)){
if (OrderCloseTime() > 0) {
// Order has been closed
break;
}
// Wait for 1 second before checking again
Sleep(1000);
}

Stop Loss
Auf diese Weise veranlassen Sie den Forex-Trading-Roboter, einen Stop-Loss für einen Trade zu setzen. Das Setzen des Stop-Loss kann anspruchsvoll sein: Manche Entwickler ziehen es vor, den Stop-Loss erst dann zu hinterlegen, wenn die Order aktiv ausgeführt wurde. In diesem Fall wird der Stop-Loss per Order-Modifikation angepasst.
In diesem Beispiel platziert der EA zunächst eine Pending-Order und passt den Stop-Loss an, sobald die Order ausgeführt wurde.
// Define order parameters
double lotSize = 0.1; // Lot size
double limitPrice = 1.2000; // Limit price
double stopLoss = 1.2100; // Stop loss
double takeProfit = 1.1900; // Take profit
// Place the pending order
int ticket = OrderSend(Symbol(), OP_SELLLIMIT, lotSize, limitPrice, 0, stopLoss, takeProfit, "Sell Limit", MagicNumber, 0, Red);
if (ticket <= 0) {
Print("Failed to place pending order with error code ", GetLastError());
} else {
Print("Pending order placed with ticket number ", ticket);
}
// Modify the stop loss for the pending order
if (OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES)) {
double newStopLoss = 1.2050; // New stop loss value
if (!OrderModify(ticket, OrderOpenPrice(), newStopLoss, OrderTakeProfit(), 0, Green)) {
Print("Failed to set stop loss for pending order with error code ", GetLastError());
} else {
Print("Stop loss set for pending order with ticket number ", ticket);
}
} else {
Print("Failed to select pending order with ticket number ", ticket, " with error code ", GetLastError());
}

Die Variablen im Code sind klar definiert:
- die Positionsgröße beträgt 1 Mini-Lot (0,1 Lot)
- der Limit-Kurs liegt bei 1.2000
- der Stop-Loss liegt bei 1.2100
- der Take-Profit liegt bei 1.1900
Zudem ist der Code so aufgebaut, dass ein Fehlercode im Journal ausgegeben wird, falls der Stop-Loss nicht modifiziert werden kann. Die Pending-Order wird über die Funktion OrderSend() mit den oben genannten Parametern übermittelt.
Wird die Order angenommen, wählt der Forex-Trading-Roboter diese über die Funktion OrderSelect() (anhand der Ticketnummer) aus. Der Parameter MODE_TRADES weist das Programm an, offene und schwebende Orders für diese Aktion zu berücksichtigen.
Mit der Funktion OrderModify() lassen sich Orderparameter im Nachhinein anpassen, wie etwa der Stop-Loss über den neuen Wert newStopLoss.
Beachten Sie beim Festlegen der Variablen die Vorgaben Ihres Brokers hinsichtlich der Häufigkeit und Mindestabstände bei Orderänderungen.
Take Profit
Falls Sie den Take-Profit nicht direkt gemeinsam mit dem Stop-Loss festlegen möchten, können Sie ihn auch separat programmieren. Dazu dient folgender Code:
void OnTick() {
// Set take profit level
double takeProfit = 1.5; // Take profit level as a multiple of the trade's open price
double stopLoss = 1.0; // Stop loss level as a multiple of the trade's open price
// Place trade with take profit and stop loss levels
int ticket = OrderSend(Symbol(), OP_BUY, 1.0, Ask, 3, Bid - stopLoss * Point, Bid + takeProfit * Point, "My Order", MagicNumber, 0, Blue);
}

In diesem Beispiel wird ein Chance-Risiko-Verhältnis von 1:1,5 für Stop-Loss und Take-Profit verwendet. Die Platzierung erfolgt erneut über die Funktion OrderSend(), wobei die Variablen stopLoss und takeProfit als Kursabstände definiert sind.
Die switch-Anweisung
Die „switch“-Anweisung wird hingegen verwendet, wenn eine Variable mit mehreren möglichen Werten verglichen werden soll. Hier ist ein Beispiel für den Einsatz von „if-else“ und „switch“ in MT4:
double price = Bid;
int tradeType = 2; // 0 = buy, 1 = sell, 2 = do nothing
// if-else statement
if (price > 1.0) {
tradeType = 0;
}else if (price < 0.5) {
tradeType = 1;
}
// switch statement
switch (tradeType) {
case 0:
// Execute this code if tradeType is 0 (buy)
OrderSend(Symbol(), OP_BUY, 0.1, price, 0, 0, 0, "Buy order", 0, 0, Green);
break;
case 1:
// Execute this code if tradeType is 1 (sell)
OrderSend(Symbol(), OP_SELL, 0.1, price, 0, 0, 0, "Sell order", 0, 0, Red);
break;
default:
// Execute this code if tradeType is not 0 or 1 (do nothing)
break;
}

Die if-else-Anweisung prüft die Bedingungen anhand des Kursniveaus:
- Liegt der Kurs über 1,0, erhält die Variable tradeType den Wert 0 -> BUY.
- Liegt der Kurs unter 0,5, erhält die Variable tradeType den Wert 1 -> SELL.
- Liegt der Kurs dazwischen (Standardfall), bleibt tradeType auf 2 -> KEINE AKTION.
Bei der switch-Anweisung steht die Variable tradeType im Mittelpunkt:
- Ist tradeType = 0, -> KAUF (BUY) zum im Code festgelegten Kurs.
- Ist tradeType = 1, -> VERKAUF (SELL) zum Kurs.
- Ist tradeType = 2, -> KEINE AKTION.
In diesen Anleitungen erfahren Sie, wie Sie Ihren Forex-Roboter auf Ihren Trading-Plattformen installieren:
So installieren Sie einen Forex-Trading-Bot in MT4
So installieren Sie einen Forex-Trading-Bot in MT5
Fazit
In diesem Artikel haben wir die grundlegenden Bausteine beleuchtet, aus denen der Code eines Forex-Roboters und automatisierter Handelssysteme besteht. Sie haben die verschiedenen Programmtypen in MQL4 kennengelernt (Forex-Trading-Bots, Indikatoren und Skripte) sowie die zentralen Sprachelemente, die zur Entwicklung nötig sind. Zudem wissen Sie nun, wie Kommentare, Datentypen, Operatoren und Bezeichner innerhalb der MQL4-Syntax zusammenspielen.
Die praktische Umsetzung dieser Grundlagen erfordert Übung und Erfahrung. Wir hoffen, dass Ihnen dieser Überblick den Einstieg in die Programmierung eigener Forex-Roboter erleichtert.



