Einführung in MQL5 (Teil 3): Beherrschung der Kernelemente von MQL5
219
0
Einführung
Willkommen zurück, liebe Händler und angehende Algorithmus-Enthusiasten! Im dritten Kapitel unserer MQL5-Reise stehen wir an der Kreuzung von Theorie und Praxis und sind bereit, die Geheimnisse hinter Arrays, nutzerdefinierten Funktionen, Präprozessoren und Ereignisbehandlung zu lüften. Unser Ziel ist es, jedem Leser, unabhängig von seinem Programmierhintergrund, ein tiefes Verständnis für diese grundlegenden MQL5-Elemente zu vermitteln.
Was diese Reise einzigartig macht, ist unser Engagement für Klarheit. Jede Zeile des Codes wird erklärt, sodass Sie nicht nur die Konzepte verstehen, sondern auch erleben, wie sie in praktischen Anwendungen zum Leben erweckt werden. Ziel ist es, einen integrativen Raum zu schaffen, in dem die Sprache von MQL5 für alle zugänglich wird. Ihre Fragen sind nicht nur willkommen, sondern auch erwünscht, wenn wir uns mit den Grundlagen befassen. Dies ist nur der Anfang, der den Grundstein für die spannenden Programmierabenteuer legt, die vor uns liegen. Lassen Sie uns gemeinsam die Welt der MQL5-Programmierung erlernen, aufbauen und erforschen.
Konzentrieren Sie sich also und nehmen Sie an dieser spannenden Erkundung teil. Gemeinsam werden wir theoretisches Wissen in praktisches Fachwissen umwandeln und dafür sorgen, dass das Verständnis für alle Menschen zunimmt. Die Bühne ist bereitet und der Code steht bereit, also lassen Sie uns in die Welt der MQL5-Meisterschaft eintauchen!
In diesem Artikel werden wir die folgenden Themen behandeln:
- Array
- Nutzerdefinierte Funktionen
- Präprozessor
- Ereignisbehandlung
Bevor wir uns in Teil 3 auf die Mitmachreise in die Tiefen der MQL5-Codierung begeben, habe ich eine aufregende Ankündigung. Um Ihre Lernerfahrung zu verbessern, werde ich eine Videozusammenfassung bereitstellen, die die wichtigsten Konzepte und Highlights aus Teil 2 unserer Untersuchung zusammenfasst. Diese visuelle Zusammenfassung soll Ihr Verständnis verstärken und komplexe Themen leichter verdaulich machen.
1. Array
Was sind Arrays?
Arrays sind grundlegende Konzepte in der Programmierung, die effiziente Möglichkeiten zur Organisation und Speicherung von Daten bieten. Sie ermöglicht es Ihnen, mehrere Werte unter einem einzigen Variablennamen zu speichern und zu organisieren. Anstatt für jede Dateneinheit separate Variablen zu erstellen, können Sie ein Array verwenden, um eine Sammlung von Elementen desselben Typs zu speichern. Auf diese Elemente kann über Indizes zugegriffen und sie können manipuliert werden.
Analogie
Ein Array ist wie eine magische Box, in der man eine Reihe ähnlicher Dinge zusammenhalten kann. Stellen Sie sich vor, Sie haben eine Reihe von Kisten, und jede Kiste hat eine Nummer. Diese Nummern helfen Ihnen, Ihre Sachen zu finden und zu organisieren. Nehmen wir an, Sie haben eine Reihe von Kästchen mit den Nummern 0, 1, 2, 3 usw. (die Zählung beginnt immer bei 0). In jeder Schachtel können Sie etwas Besonderes aufbewahren, z. B. Ihr Lieblingsspielzeug oder Süßigkeiten. Wenn Sie mit einem bestimmten Spielzeug spielen möchten, sagen Sie die Nummer der Schachtel und voila! Sie finden genau das, wonach Sie suchen. Ein Array in der Programmierung ist also wie diese Reihe nummerierter Kästchen. So können Sie viele ähnliche Artikel an einem Ort aufbewahren und sie anhand ihrer speziellen Nummern leicht finden. Das ist eine coole Art, Sachen zu organisieren!
1.1. Wie man ein Array deklariert
In MQL5 deklarieren Sie ein Array, indem Sie seinen Datentyp und Namen angeben, gefolgt von den Array-Dimensionen (falls vorhanden).
Hier ist die grundlegende Syntax:
data_type array_name[array_size];
- data_type: Der Datentyp, den das Array enthalten soll (z. B. int, double, string usw.)
- array_name: Der Name, den Sie dem Array geben.
- array_size: Die Größe oder Länge des Arrays, die angibt, wie viele Elemente es enthalten kann.
void OnStart() { int closePrices[5]; // An integer array with a size of 5, means the array has 5 integer elements double prices[10]; // A double-precision floating-point array with a size of 10 }
1.2. Werte einem Array zuweisen
In MQL5 können Sie einem Array während seiner Deklaration oder separat nach der Deklaration Werte zuweisen. Schauen wir uns beide Methoden an:
1.2.1. Zuweisung von Werten nach der Deklaration
Bei dieser Methode deklarieren Sie zunächst das Array und weisen dann jedem Element einzeln Werte zu. Sie ermöglicht die dynamische Zuweisung von Werten während der Programmausführung oder in Abhängigkeit von bestimmten Bedingungen.
Beispiel:
void OnStart() { int closePrices[5]; closePrices[0] = 10; closePrices[1] = 20; closePrices[2] = 30; closePrices[3] = 40; closePrices[4] = 50; }
1.2.2. Zuweisung von Werten während der Deklaration
In dieser Methode deklarieren Sie das Array und geben die Werte in geschweiften Klammern {} an. Die Größe des Arrays wird durch die Anzahl der von Ihnen angegebenen Werte bestimmt. In diesem Beispiel wird das Array „closePrices“ mit einer Größe von 5 deklariert und mit den Werten 10, 20, 30, 40 und 50 initialisiert. Beide Methoden sind gültig, und Sie können diejenige wählen, die Ihrem Programmierstil oder den Anforderungen Ihres spezifischen Programms entspricht.
Beispiel:
void OnStart() { int closePrices[5] = {10, 20, 30, 40, 50}; }
1.3. Wie man auf Elemente eines Arrays zugreift
In den meisten Programmiersprachen, einschließlich MQL5, beginnen Array-Indizes bei 0. Wenn Sie also ein Array deklarieren und auf seine Elemente zugreifen, beginnt die Zählung standardmäßig bei 0.
Beispiel:
void OnStart() { // Declare an integer array with a size of 5 int closePrices[5]; // Assign values to array elements closePrices[0] = 10; closePrices[1] = 20; closePrices[2] = 30; closePrices[3] = 40; closePrices[4] = 50; // Access and print array elements Print("Element at index 0: ", closePrices[0]); // Output: 10 Print("Element at index 1: ", closePrices[1]); // Output: 20 Print("Element at index 2: ", closePrices[2]); // Output: 30 Print("Element at index 3: ", closePrices[3]); // Output: 40 Print("Element at index 4: ", closePrices[4]); // Output: 50 }
Erläuterung:
Deklaration von Arrays:
int closePrices[5];
In dieser Zeile wird ein Integer-Array namens „closePrices“ mit einer festen Größe von 5 Elementen deklariert. In MQL5 können Arrays Elemente desselben Datentyps speichern, und die Indizierung beginnt bei 0, sodass dieses Array die Indizes 0 bis 4 hat.
Zuweisung von Werten zu Array-Elementen:
closePrices[0] = 10; closePrices[1] = 20; closePrices[2] = 30; closePrices[3] = 40; closePrices[4] = 50;
Hier werden den einzelnen Elementen des Arrays mit Hilfe von Indizes Werte zugewiesen. Das Array „closePrices“ enthält nun die Werte 10, 20, 30, 40 und 50 an ihren jeweiligen Positionen.
Zugriff auf und Drucken von Array-Elementen:
Print("Element at index 0: ", closePrices[0]); // Output: 10 Print("Element at index 1: ", closePrices[1]); // Output: 20 Print("Element at index 2: ", closePrices[2]); // Output: 30 Print("Element at index 3: ", closePrices[3]); // Output: 40 Print("Element at index 4: ", closePrices[4]); // Output: 50Die „Print“-Anweisungen zeigen, wie man auf die Werte, die an bestimmten Indizes im Array gespeichert sind, zugreifen und sie anzeigen kann. Es wird auf die Indizes 0 bis 4 zugegriffen, und die entsprechenden Werte werden auf der Konsole ausgegeben.
In dieser einführenden Untersuchung von MQL5-Arrays haben wir die Grundlagen aufgedeckt, indem wir die Metapher der organisierten Container für Daten verwendet haben. Anhand von Codebeispielen haben wir die Deklaration, Initialisierung und den Zugriff auf Array-Elemente demonstriert. Es ist erwähnenswert, dass MQL5 mit einer Reihe von leistungsstarken Array-Funktionen ausgestattet ist. Diese werden zwar später im Detail behandelt, aber zunächst ist es wichtig, sich mit dem grundlegenden Array-Konzept vertraut zu machen.
2. Nutzerdefinierte Funktionen
Was sind nutzerdefinierte Funktionen?
Nutzerdefinierte Funktionen, sind spezifische Codesegmente, die Sie erstellen, um eine bestimmte Aufgabe oder eine Reihe von Aufgaben in einer Programmiersprache auszuführen. Im Kontext von MQL5, das für den algorithmischen Handel verwendet wird, werden nutzerdefinierte Funktionen vom Programmierer geschrieben, um eine Reihe von Aktionen, Berechnungen oder Operationen zu kapseln. Diese Funktionen ermöglichen es Ihnen, Ihren Code zu modularisieren, wodurch er lesbarer, wiederverwendbar und leichter zu pflegen ist. Anstatt denselben Code an mehreren Stellen in Ihrem Programm zu duplizieren, können Sie eine nutzerdefinierte Funktion erstellen, die diese Logik kapselt, und die Funktion dann immer dann aufrufen, wenn diese spezielle Aufgabe ausgeführt werden muss.
Aufbauend auf dem Fundament, das in unserem vorherigen Artikel gelegt wurde, in dem wir allgemeine Funktionen wie Alert, Comment und Print erkundet haben, tauchen wir nun in das mächtige Reich der Gestaltung Ihrer Funktionen in MQL5 ein. So wie ein geschickter Handwerker seine Werkzeuge verfeinert, können Sie durch die Erstellung nutzerdefinierter Funktionen Ihren Code genau auf die Anforderungen Ihrer Handelsstrategien abstimmen.
Analogie
Stellen Sie sich vor, Sie stehen in einer Küche und bereiten eine köstliche Mahlzeit zu (Ihr Code). In der kulinarischen Welt der Programmierung sind Funktionen wie Rezepte, die Schritt-für-Schritt-Anweisungen zur Erstellung bestimmter Gerichte enthalten. Lassen Sie uns nun die Analogie zwischen nutzerdefinierten Funktionen und allgemeinen Funktionen untersuchen. Stellen Sie sich gemeinsame Funktionen wie allgemein bekannte Rezepte in Kochbüchern vor. Bei diesen Rezepten handelt es sich um Standardrezepte, die häufig verwendet werden, wie die Zubereitung einer Tasse Kaffee oder das Kochen eines Eies. In der Programmiersprache sind Funktionen wie „Alert“, „Comment“ und „Print“ mit diesen bekannten Rezepten vergleichbar. Sie dienen bestimmten Zwecken und sind sofort einsatzbereit.
Andererseits sind nutzerdefinierte Funktionen wie Ihre einzigartigen, geheimen Familienrezepte. Das sind Gerichte, die Sie selbst kreiert haben, ganz nach Ihrem Geschmack und Ihren Vorlieben. In ähnlicher Weise sind nutzerdefinierte Funktionen in der Kodierung personalisierte Sätze von Anweisungen, die vom Programmierer zur Ausführung bestimmter Aufgaben erstellt werden. Sie umfassen eine Reihe von Schritten, um ein bestimmtes Ergebnis zu erzielen, ähnlich wie Ihr Geheimrezept für den perfekten Schokoladenkuchen. Allgemeine Funktionen sind wie Fertiggerichte bequem, schnell und weithin anwendbar. Sie sind effizient für alltägliche Aufgaben, genau wie ein vorgefertigtes Abendessen, das man aufwärmen kann. Auf der anderen Seite bieten die nutzerdefinierten Funktionen Präzision und Personalisierung. Sie sind wie das Kochen von Grund auf und ermöglichen es Ihnen, Zutaten, Aromen und Techniken an die einzigartigen Anforderungen Ihrer Kodierküche anzupassen.
2.1. Wie man eine Funktion erstellt
Das Erstellen einer Funktion in MQL5 beinhaltet die Angabe des Funktionsnamens, die Definition der Parameter (falls vorhanden), die Angabe des Rückgabetyps (falls ein Wert zurückgegeben wird) und die Angabe des Codeblocks, der den Körper der Funktion bildet.
Schritt 1: Bestimmen Sie den Zweck der Funktion
Entscheiden Sie, welche Aufgabe oder Berechnung die Funktion ausführen soll. So können Sie den Namen der Funktion, die Eingabeparameter und den Rückgabetyp (falls vorhanden) bestimmen. In diesem Fall wollen wir eine Funktion erstellen, die 2 Zahlen multipliziert.
Schritt 2: Deklarieren der Funktion
Deklarieren Sie die Funktion mit dem gewählten Namen, den Eingabeparametern und dem Rückgabetyp (falls zutreffend). Die Deklaration sollte auf globaler Ebene erfolgen, außerhalb einer bestimmten Funktion oder eine der Ereignisbehandlungen.
Anmerkung: Die Ereignisbehandlungen in MQL5 sind Funktionen, die automatisch auf bestimmte Ereignisse reagieren, wie z.B. Marktpreisänderungen (OnTick), Chart-Interaktionen (OnChartEvent) und Zeitintervalle (OnTimer). Sie rationalisieren die Ausführung von Code auf der Grundlage von Echtzeit- oder geplanten Ereignissen in der MetaTrader-Plattform. Weitere Erklärungen werden folgen.
Syntax:
return_type FunctionName(parameter1_type parameter1, parameter2_type parameter2, ...)
{
// Function body (code block)
// Perform actions or calculations
// Optionally, return a value using the 'return' keyword if the function has a return type
} Schritt 3: Definieren Sie den Funktionsrumpf
Fügen Sie innerhalb der Funktion den Code hinzu, der die gewünschte Aufgabe oder Berechnung ausführt. Fügen Sie alle erforderlichen Variablen und Logik ein.
Beispiel:
double MyFunction(int param1, double param2) { // Function body: Calculate the product of the two parameters double result = param1 * param2; // Return the result return result; }
Erläuterung:
„double MyFunction(int param1, double param2)“:
- Diese Zeile definiert eine Funktion namens „MyFunction“. Sie benötigt zwei Parameter: „param1“ vom Typ „int“ (Ganzzahl) und „param2“ vom Typ „double“ (Gleitkommazahl). Es wird erwartet, dass die Funktion einen Wert vom Typ „double“ zurückgibt.
{:
- Die öffnende geschweifte Klammer „{“ markiert den Beginn des Funktionskörpers, in dem sich der eigentliche Code der Funktion befindet.
„double result = param1 * param2;“:
- Diese Zeile berechnet das Produkt aus „param1“ und „param2“ und speichert das Ergebnis in einer Variablen namens result. Da sowohl „param1“ als auch „param2“ vom numerischen Typ sind, ergibt die Multiplikationsoperation (*) ein Double.
„return result;“:
- Diese Zeile beendet die Funktion „MyFunction“ und gibt den in der Ergebnisvariablen gespeicherten Wert an den Code zurück, der die Funktion aufgerufen hat. Da der Rückgabetyp der Funktion „double“ ist, bedeutet dies, dass der Aufrufer einen Double-Wert erwartet.
“}“:
-
Die schließende geschweifte Klammer „}“ markiert das Ende des Funktionskörpers.
Schritt 4: Verwenden der Funktion
Rufen Sie die Funktion von anderen Teilen Ihres Codes aus auf. Sie können die Funktion in Ereignisbehandlungsroutinen, anderen Funktionen oder in jedem geeigneten Kontext verwenden.
Beispiel:void OnStart() { // Calling the custom function double result = MyFunction(5, 3.5); // Printing the result Print("The result is: ", result); // The output will be 17.5 }
Die bereitgestellte Funktion „MyFunction“ wurde entwickelt, um zwei Zahlen automatisch zu multiplizieren. Wenn Sie diese Funktion aufrufen und die erforderlichen numerischen Werte als Argumente angeben, wird die Berechnung unmittelbar durchgeführt und das Ergebnis zurückgegeben. Diese Abstraktion vereinfacht den Prozess der Multiplikation von Zahlen und verbessert die Lesbarkeit und Wiederverwendbarkeit des Codes.
Ich möchte Sie ermutigen, sich aktiv mit dem Inhalt zu beschäftigen und Fragen zu stellen. Ihr Verständnis ist meine Priorität, und ich bin hier, um klare Erklärungen zu geben oder weitere Klarstellungen zu jedem Thema zu bieten. Ihre Fragen tragen zu einer besseren Lernerfahrung bei, also zögern Sie nicht, sich zu melden. Ich werde mein Bestes tun, um Ihnen umgehend zu antworten und Ihnen dabei zu helfen, die in dem Artikel erörterten Konzepte zu verstehen.
3. Präprozessoren
Was sind Präprozessoren?
In der dynamischen Welt der MQL5-Programmierung sind Präprozessoren wichtige Werkzeuge, die die Art und Weise, wie der Code interpretiert und ausgeführt wird, beeinflussen. Ein Präprozessor ist eine spezialisierte Softwarekomponente, die den Quellcode bearbeitet, bevor der eigentliche Kompilierungsprozess beginnt. Seine Hauptaufgabe besteht darin, Anweisungen und Direktiven zu verarbeiten, die das Verhalten, die Struktur und die Eigenschaften des resultierenden Programms beeinflussen.
Präprozessoren arbeiten, indem sie den ursprünglichen Quellcode transformieren oder vorverarbeiten. Sie interpretieren bestimmte Anweisungen, die durch ein vorangestelltes Rautensymbol ( „#“ ) gekennzeichnet sind, und ändern den Inhalt des Codes entsprechend, bevor er kompiliert wird. Diese Direktiven, die auch als Präprozessor-Direktiven bezeichnet werden, umfassen eine Reihe von Funktionen, darunter die Definition von Konstanten, die Einbindung externer Dateien, die Festlegung von Programmeigenschaften und die Aktivierung der bedingten Kompilierung. Jede Richtlinie dient einem bestimmten Zweck, um den Code entsprechend den Anforderungen des Entwicklers zu gestalten.
Die Besonderheit von Präprozessoren liegt darin, dass sie vor der eigentlichen Kompilierung ausgeführt werden können. In dieser frühen Phase der Code-Manipulation können die Entwickler bestimmte Bedingungen, Konfigurationen oder Einschlüsse festlegen, die sich auf das endgültige kompilierte Programm auswirken werden.
Anmerkung: Bei der MQL5-Programmierung ist es wichtig, sich daran zu erinnern, dass Präprozessoren nicht wie normale Anweisungen mit einem Semikolon (;) enden und dass sie im globalen Bereich Ihres Codes deklariert werden. Diese einzigartigen Anweisungen, wie „#define“ für Makros oder „#include“ für die Einbindung von Dateien, spielen eine entscheidende Rolle bei der Gestaltung des Verhaltens und der Struktur Ihres Programms. Wenn Sie also mit Präprozessoren arbeiten, lassen Sie das Semikolon weg und stellen Sie sicher, dass sie ihren eigenen Platz im globalen Spotlight haben!
Analogie
Stellen wir uns vor, dass das Schreiben von Code so ist, als würde man einem Roboter sagen, was er tun soll. Bevor wir es dem Roboter sagen, haben wir einen besonderen Freund, den „Preprocessor“. Dieser Freund hilft uns, alles für den Roboter vorzubereiten, damit er unsere Anweisungen perfekt versteht. Stellen Sie sich den Präprozessor als einen magischen Helfer vor, der sich unsere Anweisungen ansieht, bevor es der Roboter tut. Seine Aufgabe ist es, die Dinge zu vereinfachen und zu organisieren. Manchmal wollen wir besondere Wörter verwenden, die etwas Wichtiges bedeuten, wie z. B. „MAGIC_NUMBER“ anstelle der Zahl 10. Der Präprozessor hilft uns, indem er diese speziellen Wörter versteht und sie durch reelle Zahlen ersetzt.
Beispiel:
#define MAGIC_NUMBER 10 //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void OnStart() { int result = MAGIC_NUMBER + 5; Comment(result); // Output will be 15 }
Erläuterung:
„#define MAGIC_NUMBER 10“:
- Diese Zeile ist so, als würde man sagen: „Hey Preprocessor, wann immer du das Wort „MAGIC_NUMBER“ in meinem Code siehst, ersetze es durch die Zahl 10.“ Es ist, als ob man ein spezielles Wort schafft, das für einen bestimmten Wert steht.
„void OnStart()“:
- In diesem Teil beginnt die eigentliche Handlung. „OnStart“ ist eine spezielle Funktion in MQL5, die ausgeführt wird, wenn Ihr Skript zu laufen beginnt.
„int result = MAGIC_NUMBER + 5;“:
- Hier verwenden wir unser spezielles Wort „MAGIC_NUMBER“. Der Präprozessor erkennt dies und ersetzt „MAGIC_NUMBER“ durch 10. Diese Zeile ist also dasselbe wie „int result = 10 + 5;“.
„Comment(result); // Output will be 15“:
- Die Funktion „Kommentar“ ist so, als würde man dem Roboter sagen, dass er etwas sagen soll. In diesem Fall bitten wir den Roboter, den Wert von „Ergebnis“ zu sagen, der 15 ist. Wenn Sie also dieses Skript ausführen, wird in den Kommentaren Ihres Diagramms die Zahl „15“ angezeigt.
Das Tolle daran ist, dass der Präprozessor schon funktioniert, bevor wir dem Roboter sagen, was er tun soll! Er sieht sich unsere speziellen Wörter an und bereitet alles vor, sodass der Roboter, wenn er anfängt zu arbeiten, bereits weiß, was er zu tun hat. Der Präprozessor ist also so etwas wie unser heimlicher Freund, der dafür sorgt, dass unsere Anweisungen klar sind, dass unser Code sauber ist und dass alles perfekt eingerichtet ist, damit der Roboter ihm folgen kann. Es ist, als hätte man einen Superhelden als Freund in der Welt der Programmierung!
3.1. Kategorien von Präprozessoren
3.1.1. Makro-Substitution (#define)
In der Welt der Codierung werden Makros zur Erstellung von Konstanten verwendet. Konstanten sind wie unveränderliche Werte. Mit Makros können wir spezielle Wörter erstellen, die für diese Werte stehen.
Beispiel:
#define MAGIC_NUMBER 10 //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void OnStart() { int result = MAGIC_NUMBER + 5; }
Anstatt jedes Mal die Zahl „10“ zu verwenden, nutzen wir hier einfach das Wort „MAGIC_NUMBER“, wodurch unser Code sauberer und lesbarer wird.
3.1.1.1. Parametrisierte Makros (funktionsähnliche Makros)
Stellen Sie sich vor, Sie haben ein magisches Rezept, und manchmal möchten Sie eine wichtige Zutat ändern. Mit parametrisierten Makros können Sie flexible Anweisungen erstellen.
Beispiel:
#define MULTIPLY(x, y) (x * y) //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void OnStart() { int result = MULTIPLY(3, 5); // Result is 15 }
Hier nimmt das Makro „MULTIPLY“ zwei Zutaten (Zahlen) und multipliziert sie. Es ist, als hätte man eine magische Funktion in seinem Code!
Erläuterung:
„#define MULTIPLY(x, y) (x * y)“:
- Diese Zeile ist so, als würde man dem Computer sagen: „Hey, wenn ich „MULTIPLY“ sage, dann meine ich zwei Zahlen (nennen wir sie „x“ und „y“) und multipliziere sie miteinander.“ Es ist, als würde man mit unserem Zauberwort eine Multiplikationsmaschine schaffen.
“int result = MULTIPLY(3, 5);“:
- Hier verwenden wir unser Zauberwort „MULTIPLY“. Der Computer sieht dies und weiß, dass es bedeutet: „Nimm die Zahlen 3 und 5 und multipliziere sie“. Er ersetzt also MULTIPLY(3, 5) durch (3 * 5).
„// result is 15“:
- Das Ergebnis der Multiplikation von 3 und 5 ist 15. Nachdem der Computer die Berechnung durchgeführt hat, ist der Wert von „result“ also 15.
Dieser Code vereinfacht im Wesentlichen den Multiplikationsprozess. Anstatt direkt „3 * 5“ zu schreiben, verwenden wir das Zauberwort „MULTIPLY“, um unseren Code lesbarer und leichter verständlich zu machen. Es ist, als hätten wir einen Mini-Mathe-Assistenten in unserem Code!
3.1.1.2. Die Richtlinie #undef
Die „#undef“-Richtlinie ist wie die Aufforderung: „Vergesst, was ich euch vorhin gesagt habe; lasst uns neu anfangen.“ In der Welt der MQL5-Programmierung erlaubt es uns, ein zuvor definiertes Makro rückgängig zu machen oder zu „entwerfen“. Es ist, als würde man eine Notiz auf einem magischen Whiteboard ausradieren.
Beispiel:
#define MAGIC_NUMBER 10 //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void OnStart() { int result = MAGIC_NUMBER + 5; #undef MAGIC_NUMBER // Undefining MAGIC_NUMBER }
Erläuterung:
“#define MAGIC_NUMBER 10“:
- Zunächst definieren wir ein Makro namens „MAGIC_NUMBER“ und setzen seinen Wert auf 10. Das ist so, als würde man sagen: „Immer wenn ich „MAGIC_NUMBER“ verwende, meine ich die Zahl 10“.
„int result = MAGIC_NUMBER + 5;“:
- Wir verwenden die „MAGIC_NUMBER“ in einer Berechnung, bei der das Ergebnis 15 ist.
“#undef MAGIC_NUMBER“:
- Mit „#undef MAGIC_NUMBER“ sagen wir: „Okay, vergesst, was „MAGIC_NUMBER“ vorher bedeutet hat.“ Das ist so, als würde man die Definition löschen und „MAGIC_NUMBER“ undefiniert machen.
3.1.2. Programm-Eigenschaften (#property)
In der Welt der Programmierung hat jedes Programm seine eigenen Merkmale, wie eine Figur in einer Geschichte. Mit „#property“ können wir unserem Programm besondere Eigenschaften und Qualitäten verleihen. Es ist, als würde man sagen: „Hey Computer, hier sind einige Dinge, die mein Programm besonders machen. Stellen Sie sich vor, Sie schreiben ein Buch oder einen Song und möchten den Menschen mitteilen, wer ihn geschaffen hat und wann er entstanden ist. Mit „#property“ können wir das auch für unsere Programme tun. Das ist so, als ob wir am Anfang unseres Codes eine kleine Notiz hinzufügen würden, die besagt: „Dieses Programm ist Version 1.0, und ich habe es im Jahr 2022 erstellt.
Beispiel:
#property copyright "crownsoyin" #property version "1.00"
Ergebnis Nach Ausführung des Codes
“#property“ ist wie die Titelseite eines Buches oder der Vorspann eines Films. Er gibt den Ton an, liefert Informationen über das Programm und hilft allen, einschließlich dem Programmierer und anderen, die den Code später lesen könnten, zu verstehen, was vor sich geht.
3.1.3 Einbindungsrichtlinie (#include)
Was ist eine Include-Datei?
Stellen Sie sich vor, Sie haben ein magisches Rezeptbuch, aber einige Rezepte sind in einem anderen Buch gespeichert. Mit „#include“ sagen Sie: „Hey, lass uns diese zusätzlichen Rezepte aus dem anderen Buch in eine große Rezeptsammlung einbringen.“ Bei der Programmierung hilft es uns, externe Dateien mit unserem Hauptcode zusammenzuführen und alles an einem Ort zugänglich zu machen. Stellen Sie sich das Programmieren wie den Bau eines Hauses mit verschiedenen Räumen vor. Jeder Raum hat bestimmte Funktionen, wie eine Küche oder ein Schlafzimmer. Mit „#include“ können wir diese Räume (Funktionen und Strukturen) in anderen Häusern (Programmen) wiederverwenden. Es ist, als würde man sagen: „Ich habe diese fantastische Küche gebaut; jetzt kann ich sie in allen meinen Häusern verwenden, ohne sie von Grund auf neu zu bauen.
Beispiel:
#include "extraRecipes.mqh" // Include external file with extra recipes
Erläuterung:
„#include“:
- Stellen Sie sich „#include“ als einen magischen Befehl vor, der besagt: „Bringen Sie etwas Besonderes von einem anderen Ort mit und fügen Sie es hier ein.“ Es ist, als hätte man ein geheimes Portal, um zusätzliche Zutaten für unser Rezept zu erhalten.
„"extraRecipes.mqh" “:
- Der Text innerhalb der Anführungszeichen ist der Name der externen Datei, die wir einbinden wollen. In diesem Fall ist es „extraRecipes.mqh“. Diese Datei enthält zusätzliche Rezepte oder Code, die wir in unserem Hauptprogramm verwenden wollen.
Wenn wir also „ #include "extraRecipes.mqh" “ schreiben, ist das so, als würden wir ein geheimes Kochbuch öffnen und sagen: „Fügen wir diese zusätzlichen Rezepte zu unseren Hauptkochanweisungen hinzu.“ Dies hilft, unseren Hauptcode sauber und organisiert zu halten, während wir immer noch Zugriff auf die zusätzliche Magie von „extraRecipes.mqh“ haben. Es ist, als ob wir unser magisches Kochbuch mit weiteren Zaubersprüchen und Verzauberungen erweitern würden! Wenn Sie „#include“ verwenden, um eine externe Datei in Ihren Code einzubinden, werden alle in dieser externen Datei definierten Funktionen oder Strukturen zugänglich und können in Ihrem Hauptcode verwendet werden.
Beispiele:
Externe Datei: “extraRecipes.mqh”
// extraRecipes.mqh int MultiplyByTwo(int number) // function from an external file { return number * 2; }
Hauptcode:
// Your main code #include "extraRecipes.mqh" // Include external file with extra recipes //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void OnStart() { int result = MultiplyByTwo(5); // Using the function from the included file Print("Result: ", result); // Output: Result: 10 }
In diesem Beispiel ist die Funktion „MultiplyByTwo“ in der externen Datei „extraRecipes.mqh“ definiert. Durch die Verwendung von #include „“extraRecipes.mqh““ in Ihrem Hauptcode können Sie nun die Funktion „MultiplyByTwo“ aufrufen und verwenden, als ob sie direkt in Ihrem Hauptcode definiert wäre.
Die Feinheiten der Codeeinbindung und der Funktionsverwendung zu verstehen, mag anfangs etwas kompliziert erscheinen - und das ist auch gut so! Programmieren ist wie das Erlernen einer neuen Sprache, und jede Reise beginnt mit dem ersten Schritt. Wenn Sie sich am Kopf kratzen oder ein wenig verwirrt fühlen, zögern Sie nicht, Fragen zu stellen. Ihre Neugier treibt den Lernprozess voran, und ich bin hier, um Ihnen dabei zu helfen, alle Geheimnisse zu entschlüsseln. Lassen Sie sich also auf das Lernabenteuer ein, und denken Sie daran, dass Fragen der Schlüssel zu einem tieferen Verständnis sind. Wenn Sie Fragen haben, lassen Sie es uns wissen, und lassen Sie uns gemeinsam auf diese Programmierreise gehen!
3.1.4. Kompilierungsbedingungen ( #ifdef, #ifndef, #else, #endif)
Kompilierungsbedingungen ermöglichen es uns, Teile des Codes während des Kompilierungsprozesses einzuschließen oder auszuschließen. Es ist, als hätte man spezielle Anweisungen, die den Compiler anleiten, was er unter bestimmten Bedingungen einfügen soll.
3.1.4.1. „#ifdef“ Richtlinie
Die #ifdef-Direktive in MQL5 ist eine Präprozessor-Direktive, die überprüft, ob ein bestimmtes Symbol definiert ist. Wenn das Symbol definiert ist, wird der auf #ifdef folgende Codeblock während der Kompilierung eingeschlossen; andernfalls wird der auf #else oder #endif folgende Codeblock eingeschlossen.
Beispiel:
#define MAGIC_NUMBER 10 //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void OnStart() { #ifdef MAGIC_NUMBER Print(MAGIC_NUMBER); #else Print(MAGIC_NUMBER); #endif }
Erläuterung:
- In diesem Beispiel wird „MAGIC_NUMBER“ mit „#define“ definiert.
- Das „#ifdef MAGIC_NUMBER“ prüft, ob „MAGIC_NUMBER“ definiert ist.
- Da er definiert ist, wird der Codeblock nach „#ifdef“ eingeschlossen, was zur Kompilierung der ersten „Print“-Anweisung führt.
- Wäre „MAGIC_NUMBER“ nicht definiert, würde der auf „#else“ folgende Codeblock eingeschlossen und die zweite „Print“-Anweisung kompiliert werden.
“#ifdef“ wird häufig für die bedingte Kompilierung verwendet, die es Entwicklern ermöglicht, bestimmte Codeabschnitte auf der Grundlage von vordefinierten Symbolen einzuschließen oder auszuschließen. Es ist ein wertvolles Werkzeug zur Erstellung von anpassungsfähigem und konfigurierbarem Code, mit dem Entwickler ihre Anwendungen auf der Grundlage definierter Symbole oder Bedingungen während des Kompilierungsprozesses anpassen können.
3.1.4.2. Richtlinie „#ifndef“
Die „#ifndef“-Direktive in MQL5 ist eine Präprozessor-Direktive, die überprüft, ob ein bestimmtes Symbol nicht definiert ist. Wenn das Makro nicht definiert ist, wird der auf „#ifndef“ folgende Codeblock bei der Kompilierung eingeschlossen; andernfalls wird der auf „#else“ oder „#endif“ folgende Codeblock eingeschlossen.
Beispiel:
void OnStart() { #ifndef MAGIC_NUMBER Print(MAGIC_NUMBER); #else Print(MAGIC_NUMBER); #endif }
Erläuterung:
- Das „#ifndef MAGIC_NUMBER“ prüft, ob „MAGIC_NUMBER“ nicht definiert ist.
- Wenn „MAGIC_NUMBER“ nicht definiert ist, wird der Codeblock nach „#ifndef“ eingefügt und eine Meldung ausgegeben, dass „MAGIC_NUMBER“ nicht definiert ist.
- Wenn „MAGIC_NUMBER“ definiert ist, wird der auf „#else“ folgende Codeblock eingefügt, der den Wert von „MAGIC_NUMBER“ ausgibt.
Dieser Code demonstriert die Verwendung der bedingten Kompilierung, die darauf basiert, ob ein bestimmtes Makro (in diesem Fall „MAGIC_NUMBER“) definiert ist oder nicht. Je nachdem, ob das Makro vorhanden ist oder nicht, werden bei der Kompilierung unterschiedliche Codeblöcke eingefügt.
Anmerkung: „MAGIC_NUMBER“ wurde in diesem Beispiel nicht definiert
3.1.4.3. „#endif“-Richtlinie
Die „#endif“-Direktive in MQL5 markiert das Ende eines bedingten Codeblocks, der durch Direktiven wie „#ifdef“ oder „#ifndef“ eingeleitet wurde. Er dient als Signal für den Präprozessor, dass der Abschnitt der bedingten Kompilierung abgeschlossen ist und der nachfolgende Code für die Kompilierung verarbeitet werden sollte. Er hat keine Bedingungen oder Parameter, sondern dient dazu, das Ende des bedingten Kompilierungsblocks zu kennzeichnen.
Beispiel:
#define MAGIC_NUMBER 10 //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void OnStart() { #ifndef MAGIC_NUMBER Print(MAGIC_NUMBER); #else Print(MAGIC_NUMBER); #endif }
Erläuterung:
- „#endif“ markiert das Ende des bedingten Blocks, und der nachfolgende Code wird normal verarbeitet.
Anmerkung: Verbinden Sie „#endif“ immer mit einer öffnenden bedingten Anweisung (#ifdef oder #ifndef), um eine korrekte Syntax zu gewährleisten und Kompilierungsfehler zu vermeiden.
In diesem kurzen Einblick in die MQL5-Präprozessoren haben wir Makros zur Erstellung von Konstanten, Programmeigenschaften (#properties) zur Definition von Merkmalen, Include-Dateien für Modularität und bedingte Kompilierung für flexiblen Code behandelt. Dies ist zwar nur eine Einführung, aber es gibt noch viel mehr zu entdecken. Diese Werkzeuge bilden die Bausteine einer effizienten MQL5-Programmierung und bieten Vielseitigkeit und Anpassungsfähigkeit. Zögern Sie nicht, Fragen zu stellen und diese Konzepte zu vertiefen, während Sie Ihre Reise zur Entwicklung leistungsstarker Handelsalgorithmen fortsetzen. Seien Sie neugierig, und lassen Sie Ihr Verständnis für Präprozessoren organisch wachsen.
4. Handhabung von Ereignissen
Was sind Ereignisse?
Ein Ereignis in der Programmierung bezieht sich auf ein bestimmtes Vorkommnis oder Ereignis, das während der Ausführung eines Programms stattfindet. Ereignisse können durch verschiedene Aktionen ausgelöst werden, z. B. durch Nutzerinteraktionen und Änderungen des Systemzustands. Im Kontext von MQL5 sind Ereignisse entscheidend für die Entwicklung von algorithmischen Handelsskripten, die dynamisch auf Marktbedingungen reagieren.
Was ist eine Ereignisbehandlung?
Eine Ereignisbehandlung ist ein bestimmter Codeabschnitt, der für die Reaktion auf eine bestimmte Art von Ereignis verantwortlich ist. MQL5 hat dafür Funktionen, die ausgeführt werden, wenn ein bestimmtes Ereignis eintritt. Diese Funktionen sind vordefiniert und dienen als festgelegte Reaktionsmechanismen für verschiedene Ereignisse. Für jede Art von Ereignis gibt es eine entsprechende Ereignisbehandlungsfunktion.
Analogie
Stellen Sie sich vor, Sie sind in einem magischen Puppentheater, und die Puppen bewegen sich und sprechen, wenn bestimmte Dinge passieren, z. B. wenn das Publikum klatscht oder wenn ein besonderer Knopf gedrückt wird. Stellen Sie sich die Puppen als verschiedene Teile eines Computerprogramms vor, und die magische Taste als ein Ereignis. Die Ereignisbehandlung ist so etwas wie der Puppenspieler hinter den Kulissen, der auf das Eintreten bestimmter Momente (Ereignisse) wartet. Wenn ein Ereignis eintritt, tritt die Ereignisbehandlung in Aktion und lässt das Programm etwas Besonderes tun, so wie der Puppenspieler die Puppen tanzen oder sprechen lässt, wenn das Publikum jubelt oder eine Taste gedrückt wird. In der Welt der Programmierung ist eine Ereignisbehandlung also so etwas wie der magische Puppenspieler, der Dinge zum Leben erweckt, wenn bestimmte Ereignisse eintreten!
4.1. Typen der Ereignisbehandlung
4.1.1. OnInit
In MQL5 ist „OnInit“ eine spezielle Funktion, die in Expert Advisors (EAs) verwendet wird, um den EA zu initialisieren, wenn er zum ersten Mal in einen Chart geladen wird.
Analogie:
Also gut, stellen wir uns vor, Sie haben einen magischen Roboterfreund. Bevor der Roboter etwas Aufregendes tut, wie sich bewegen oder lustige Geräusche machen, muss er sich vorbereiten. Das „Vorbereiten“ ist wie der „OnInit“-Moment des Roboters. Wenn Sie also den Roboter zum ersten Mal einschalten, geht er in einen speziellen Raum (die OnInit-Funktion), wo er sich vorbereiten kann. Hier stellt es seine Lieblingsfarben ein, entscheidet, wie schnell es sich bewegen soll, und stellt sicher, dass alles richtig ist. Sobald alles eingerichtet ist, kann der Roboter herauskommen und seine coolen Tricks vorführen, zum Beispiel tanzen oder Witze erzählen.
In Computerprogrammen funktioniert die Funktion „OnInit“ auf ähnliche Weise. Es ist ein spezieller Raum, in dem sich das Programm vorbereiten kann, bevor es mit seinen Aufgaben beginnt. Es ist so etwas wie die Eröffnungszeremonie für das Programm, bei der sichergestellt wird, dass alles an seinem Platz ist und es losgehen kann!
Beispiele:
// Declare global variables double LotSize; int TakeProfit; int StopLoss; //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ // OnInit function int OnInit() { // Set EA parameters LotSize = 0.1; TakeProfit = 50; StopLoss = 30; // Display initialization message Print("EA is getting ready. Lot Size: ", LotSize, ", Take Profit: ", TakeProfit, ", Stop Loss: ", StopLoss); return(INIT_SUCCEEDED); }
Erläuterung:
- Wir deklarieren einige globale Variablen, die der EA verwenden könnte.
- Mit der Funktion OnInit werden diese Variablen initialisiert und alle erforderlichen Einstellungen vorgenommen. In diesem Beispiel setzen wir Werte für „LotSize“, „TakeProfit“ und „StopLoss“.
- Die „Print“-Anweisung ist wie eine Nachricht, die der EA an die Konsole senden kann, um uns über seine Initialisierung zu informieren. Es ist, als würde der Roboter sagen: „Ich bereite mich vor, und hier sind meine Einstellungen“.
Wenn Sie diesen EA auf einem Chart starten, wird die Funktion „OnInit“ einmal ausgeführt, und die Konsole zeigt die Initialisierungsmeldung an. Dadurch wird sichergestellt, dass der EA mit seinen Einstellungen fertig ist, bevor er mit dem Handel oder anderen Aktionen beginnt.
4.1.2. OnStart
In MQL5 ist die Funktion „OnStart“ ein wichtiger Bestandteil von Skripten und Expert Advisors (EAs). Seine Hauptaufgabe besteht darin, Befehle nur einmal auszuführen, wenn das Skript aktiviert oder gestartet wird. Es ist der erste Einstiegspunkt für die Ausführung des Skripts. Im Falle eines Skripts führt die Funktion „OnStart“ die definierte Logik aus, die das Platzieren von Geschäften, die Durchführung von Berechnungen oder andere Aktionen beinhalten kann. Im Gegensatz zu einem Expert Advisor (EA), der kontinuierlich läuft und die Bedingungen in „OnStart neu bewertet, führt ein Skript seine Logik in der Regel nur einmal aus und ist dann beendet.
Wenn Sie also handelsbezogene Aktionen in der „OnStart“-Funktion eines MQL5-Skripts haben, werden diese Aktionen ausgeführt, wenn das Skript aktiviert wird, aber das Skript wird nicht kontinuierlich den Markt überwachen oder zusätzliche Geschäfte ausführen.
Beispiel:
/+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ // This script prints a message to the console when activated // Entry point when the script is started void OnStart() { // Print a message to the console Print("Script Activated! Hello, Traders!"); }
Erläuterung:
- Die Funktion „OnStart“ ist der Einstiegspunkt des Skripts.
- Die Funktion „Print“ wird verwendet, um eine Nachricht in der Registerkarte „Experten“ des „Terminal“-Fensters des MetaTrader-Terminals anzuzeigen.
- Wenn Sie dieses Skript auf einem Chart starten oder es im MetaEditor ausführen, wird die angegebene Meldung in der Konsole angezeigt. Sie können die Druckanweisung nach Belieben ändern und eine komplexere Logik entsprechend den Anforderungen Ihres Skripts hinzufügen.
Wenn dieses Skript auf einem Skript gestartet wird, wird die Funktion „OnStart“ einmal ausgeführt. Die Funktion „OnStart“ in einem Skript dient in der Regel dazu, Initialisierungsaufgaben durchzuführen oder bestimmte Aktionen auszuführen, wenn das Skript an das Diagramm angehängt wird. Nachdem das Skript seine Logik ausgeführt hat, schließt es seinen Vorgang ab.
4.1.3. OnTick
In MQL5 ist die Funktion „OnTick“ ein entscheidender Bestandteil eines Expert Advisors (EAs). Seine Hauptaufgabe besteht darin, die zentrale Handelslogik und die Aktionen zu enthalten, die bei jedem Tick des Marktes ausgeführt werden sollen. EAs verwenden „OnTick“, um Preisänderungen zu überwachen, die Marktbedingungen zu analysieren und Entscheidungen auf der Grundlage vordefinierter Handelsstrategien zu treffen. Auftragsbezogene Aktionen, wie das Eröffnen, Ändern oder Schließen von Positionen, werden in der Regel in der Funktion „OnTick“ ausgeführt.
Analogie
Stellen Sie sich „OnTick“ so vor, dass Ihr Handelsfreund TickTrader einen belebten Markt erkundet. Jedes Tick ist wie eine neue Chance oder Veränderung. TickTrader ist immer auf der Suche nach guten Handelsgeschäften, genau wie Sie auf einem lebhaften Markt nach den besten Angeboten suchen.
Wenn der Markt ruhig ist, kann der TickTrader es langsam angehen lassen und sich nur umsehen, ohne schnell zu kaufen oder zu verkaufen. Ähnlich verhält es sich, wenn „OnTick“ feststellt, dass die Dinge bei jedem Tick ruhig bleiben, dann könnte sie vorschlagen, vorsichtig zu sein und sich auf dem Markt umzusehen. Wenn die Preise plötzlich steigen, sieht TickTrader vielleicht ein gutes Angebot und beschließt zu kaufen. Wenn „OnTick“ bei jedem Tick eine große Preisveränderung feststellt, kann sie ebenfalls vorschlagen, gute Gelegenheiten zu nutzen, wie z. B. günstige Angebote auf dem Markt.
In dieser lebhaften Marktszene ist der TickTrader immer bereit für die nächste Gelegenheit und trifft Entscheidungen, während die Ticks kommen. Auch „OnTick“ arbeitet in Echtzeit, passt sich an jeden Tick an und steuert die Handelsaktionen auf dem dynamischen Markt.
Beispiel:// Declare a variable to store the last tick's close price double lastClose; //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ // OnInit function int OnInit() { // Initialize the variable with the current close price lastClose = iClose(_Symbol, PERIOD_CURRENT, 0); return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { // Get the current close price double currentClose = iClose(_Symbol, PERIOD_CURRENT, 0); // Check if the close price has changed if(currentClose != lastClose) { // Print a message when the close price changes Print("Close price changed! New close price: ", currentClose); // Update the last close price lastClose = currentClose; } }
Erläuterung:
Erklärung der Variablen:
// Declare a variable to store the last tick's close price double lastClose;
Wir haben eine Variable „lastClose“ vom Typ „double“ deklariert, um den Schlusskurs des letzten Ticks zu speichern.
Die Initialisierung in OnInit:
nt OnInit() { // Initialize the variable with the current close price lastClose = iClose(_Symbol, PERIOD_CURRENT, 0); return(INIT_SUCCEEDED); }
In der Funktion „OnInit“ initialisieren wir „lastClose“ mit dem Schlusskurs der letzten Kerze unter Verwendung der Funktion „iClose“. Die Parameter „_Symbol“, „PERIOD_CURRENT“ und „0“ geben das aktuelle Symbol, den aktuellen Zeitrahmen bzw. die letzte Kerze an.
Die Funktion OnTick:
void OnTick() { // Get the current close price double currentClose = iClose(_Symbol, PERIOD_CURRENT, 0); // Check if the close price has changed if(currentClose != lastClose) { // Print a message when the close price changes Print("Close price changed! New close price: ", currentClose); // Update the last close price lastClose = currentClose; } }
- In der Funktion „OnTick“ wird der aktuelle Schlusskurs mit „iClose“ ermittelt und in der Variablen „currentClose“ gespeichert.
- Anschließend wird geprüft, ob sich der aktuelle Schlusskurs vom letzten aufgezeichneten Schlusskurs unterscheidet (“currentClose != lastClose“).
- Wenn es eine Änderung gibt, wird eine Meldung über die Änderung gedruckt und die Variable „lastClose“ aktualisiert.
Dieser Code überwacht und druckt eine Meldung, wenn sich der Schlusskurs bei jedem Tick ändert. Sie zeigt, wie die Funktion „OnTick“ genutzt werden kann, um auf die Marktdynamik in Echtzeit zu reagieren.
Schlussfolgerung
In diesem Artikel haben wir uns mit den grundlegenden Aspekten von MQL5 befasst und die Konzepte von Arrays, nutzerdefinierten Funktionen, Präprozessoren und Ereignisbehandlung untersucht. Ich möchte Sie, liebe Leserinnen und Leser, ermutigen, sich auf die Lernreise einzulassen und sich frei zu fühlen, alle Fragen zu stellen, die sich ergeben könnten. Ihr Verständnis dieser grundlegenden Elemente wird den Weg für unsere kommenden Diskussionen über die Erstellung leistungsstarker Handelsroboter ebnen. Denken Sie daran: Wissen wächst mit der Neugier, und Ihre Fragen sind der Keim für ein tieferes Verständnis. Bleiben Sie dran für die nächsten Folgen, in denen wir uns gemeinsam auf die aufregende Reise begeben, Handelsroboter zu entwickeln. Nehmen Sie sich erst einmal die Zeit, sich mit diesen Grundbegriffen vertraut zu machen. Viel Spaß beim Codieren und viel Erfolg bei Ihren Handelsbemühungen und bei Ihrer Suche nach Wissen!
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/14099
Implementierung des verallgemeinerten Hurst-Exponenten und des Varianz-Verhältnis-Tests in MQL5
Wie man einen einfachen Multi-Currency Expert Advisor mit MQL5 erstellt (Teil 6): Zwei RSI-Indikatoren kreuzen ihre Linien
Aufbau und Test von Keltner-Kanal-Handelssystemen
Aufbau und Test des Handelssystems Aroon
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.