Einführung in MQL5 (Teil 6): Eine Anleitung für Anfänger zu den Array-Funktionen in MQL5

Einführung

Willkommen zum sechsten Teil unserer MQL5-Reise! Es erwartet Sie eine faszinierende Fortsetzung unserer Serie, in der wir uns mit den Besonderheiten der MQL5-Programmierung befassen und Sie mit dem Wissen und den Fähigkeiten ausstatten, die Sie benötigen, um sich erfolgreich in der dynamischen Welt des automatisierten Handels zu bewegen. In diesem Kapitel werden wir uns näher mit den Array-Funktionen befassen. In Teil 5 haben wir die Grundlagen geschaffen, indem wir einige Array-Funktionen eingeführt haben.

In Teil 6 werden wir uns mit den übrigen Array-Funktionen befassen, um sicherzustellen, dass Sie diese nützlichen Werkzeuge gründlich beherrschen. Unser Ziel ist es nach wie vor, die grundlegenden Ideen zu vermitteln, die für die Automatisierung von Handelsstrategien erforderlich sind, unabhängig davon, wie viel Erfahrung Sie als Entwickler haben oder wie vertraut Sie mit dem algorithmischen Handel sind. Unser Ziel bei der Vertiefung in die Nuancen dieser Funktionen ist es, ein umfassendes Verständnis zu fördern, damit jeder Leser das sich ständig verändernde Terrain der MQL5-Programmierung kompetent durchqueren kann.

In diesem Artikel werden wir die folgenden Array-Funktionen behandeln:

• ArrayPrint
  
• ArrayInsert
  
• ArraySize
  
• ArrayRange
  
• ArrarRemove
  
• ArraySwap
  
• ArrayReverse
  
• ArraySort

1. ArrayPrint

In MQL5 können Sie die Elemente eines Arrays mit der vordefinierten Funktion „ArrayPrint()“ drucken. Diese Funktion wird häufig zur Fehlersuche verwendet, da sie eine schnelle und praktische Möglichkeit bietet, die in einem Array gespeicherten Werte anzuzeigen, während ein Algorithmus oder Skript läuft. Um Händlern und Entwicklern die Verfolgung und Validierung der Daten an verschiedenen Stellen in ihrem Code zu erleichtern, gibt die Funktion die Array-Elemente auf der Konsole oder im Journal aus.

Analogie

Angenommen, Sie haben ein eigenes Bücherregal, in dem Sie Ihre Bücher aufbewahren. Es kann vorkommen, dass Sie vergessen, welche Bücher in welchem Regal stehen. Betrachten Sie nun „ArrayPrint()“ als die geheime Phrase, mit der Sie jeden Buchtitel in Ihrem Regal anzeigen können, ohne jedes einzelne Buch physisch zu besuchen. Sagen Sie „ArrayPrint()“, um eine übersichtliche Liste aller Buchtitel in Ihrem Regal zu sehen, wenn Sie sich nach den Büchern erkundigen, die Sie besitzen. Das ist so, als würden Sie Ihr Bücherregal schnell durchsuchen, um sicherzustellen, dass alle Ihre Lieblingstitel vorhanden sind!

Betrachten Sie „ArrayPrint()“ als den magischen Befehl, den Sie Ihrem intelligenten Bücherregal geben, wenn Sie in der Lage sein wollen, die Titel zu sehen und sie gezielt zu organisieren. Mit diesem Befehl können Sie angeben, wie viele Informationen Sie für jedes Buch haben möchten, z. B. den Autor und das Erscheinungsdatum, oder ob Sie nur die Titel sehen möchten. Sogar die Reihenfolge, in der die Titel erscheinen, ist anpassbar. „ArrayPrint()“ kann noch viel mehr, worauf wir später noch eingehen werden. Sie beschränkt sich nicht nur auf die Anzeige der Titel Ihrer Bücher. Erwarten Sie die Magie mit Spannung!

Syntax:

ArrayPrint(array[], digit , Separator, Start, Count, Flags);

Parameter:

• array[]: Dies ist das zu druckende Array. Es kann ein Array verschiedener Datentypen oder ein Array aus einer einfachen Struktur sein.
  
• Digits: Die Anzahl der Dezimalstellen, die für jede Zahl im Array angezeigt werden sollen, wird durch diesen Parameter festgelegt.
  
• Separator: Dieser Parameter gibt den Abstand an, der zwischen den einzelnen Elementen des Arrays liegen soll, wenn es gedruckt wird.
  
• Start: Er gibt den Index des Elements an, bei dem der Druckvorgang beginnen soll.
  
• Count: Hier wird die Anzahl der zu druckenden Elemente angegeben.
  
• Flags: wird verwendet, um die Ausgabe zu modifizieren. Dies ist optional, da es standardmäßig aktiviert ist. ARRAYPRINT_HEADER (dieses Flag druckt Kopfzeilen für das Struktur-Array), ARRAYPRINT_INDEX (es druckt den Index auf der linken Seite) und ARRAYPRINT_LIMIT (es druckt nur die ersten 100 und die letzten 100 Array-Elemente). ARRAYPRINT_ALIGN (dieses Flag ermöglicht die Ausrichtung der gedruckten Werte) und ARRAYPRINT_DATE (es druckt das Datum in Tag, Monat und Jahr).
  

Beispiel:

void OnStart()
  {

// Define an array of doubles
   double ThisArray[] = { 1.46647, 2.76628, 3.83367, 4.36636, 5.9393};

// Print the entire array using ArrayPrint with 2 decimal places and a single spacing between array elements
   ArrayPrint(Array,2," ",0,WHOLE_ARRAY);

  }

Erläuterung:

In diesem Codeschnipsel arbeiten wir mit einem Array von Double-Werten mit einem bestimmten Namen. Das Feld wird mit fünf Elementen definiert, die jeweils eine Dezimalzahl enthalten. Die folgende Zeile verwendet die Funktion „ArrayPrint()“, um den gesamten Inhalt des Arrays anzuzeigen.

Schauen wir uns die Parameter an, die in der Funktion „ArrayPrint()“ verwendet werden:

• „ThisArray“: Dies ist das Array, das wir drucken wollen.
  
• „2“: Gibt die Anzahl der Dezimalstellen an, die für jedes Element im Array angezeigt werden sollen.
  
• „ “: Setzt ein einzelnes Leerzeichen als Trennzeichen zwischen Arrayelementen.
  
• „0“: gibt an, dass der Druck am Anfang des Arrays beginnt.
  
• „WHOLE_ARRAY“: Gibt an, dass das gesamte Array gedruckt werden soll.
  

Ausgabe:

Dies veranschaulicht die Funktionsweise von „ArrayPrint()“ mit ‚double‘-Werten in Aktion. Schauen wir uns nun einige weitere Beispiele an, die Strukturen verwenden. Während wir die Möglichkeiten der Verwendung von „ArrayPrint()“ zum Organisieren und Anzeigen strukturierter Daten erkunden, machen Sie sich auf ein wenig mehr Kompliziertheit gefasst.

Beispiel:

void OnStart()
  {

// Define a structure for storing information about students
   struct StudentsDetails
     {
      string         name;
      int            age;
      string         address;
      datetime       time; // Add a time field
     };

// Create an array of Students structures
   StudentsDetails Students[3];

// Fill in details for each person
   Students[0].name = "Abioye";
   Students[0].age = 25;
   Students[0].address = "123 MQL5 St";
   Students[0].time = TimeCurrent();

   Students[1].name = "Israel";
   Students[1].age = 26;
   Students[1].address = "456 MQL4 St";
   Students[1].time = TimeCurrent();

   Students[2].name = "Pelumi";
   Students[2].age = 27;
   Students[2].address = "789 MetaQuotes St";
   Students[2].time = TimeCurrent();

// Print the details of each person using ArrayPrint
   ArrayPrint(Students, 0, " | ", 0, WHOLE_ARRAY);

  }

Erläuterung:

struct StudentsDetails
{
   string         name;
   int            age;
   string         address;
   datetime       time; // Add a time field
};

• Zur Speicherung von Schülerdaten wird eine Struktur namens „StudentsDetails“ definiert.
  
• Der Name, das Alter (age), die Adresse, die Uhrzeit und das Datum des aktuellen Tages werden als Elemente der Struktur hinzugefügt.
  

StudentsDetails Students[3];

• Es wird ein Array mit dem Namen Students vom Typ „StudentsDetails“ mit einer Größe von 3 erstellt, das Platz für drei Studenten bietet.
  

Students[0].name = "Abioye";
Students[0].age = 25;
Students[0].address = "123 MQL5 St";
Students[0].time = TimeCurrent();

Students[1].name = "Israel";
Students[1].age = 26;
Students[1].address = "456 MQL4 St";
Students[1].time = TimeCurrent();

Students[2].name = "Pelumi";
Students[2].age = 27;
Students[2].address = "789 MetaQuotes St";
Students[2].time = TimeCurrent();

• Die Angaben zu jedem Schüler werden ausgefüllt. So werden beispielsweise den Feldern Name, Alter, Adresse und Uhrzeit Werte zugewiesen, und „Schüler[0]“ steht für den ersten Schüler.
  

ArrayPrint(Students, 0, " | ", 0, WHOLE_ARRAY);

• Um alle Informationen des Schülers in dem Array anzuzeigen, wird die Funktion „ArrayPrint()“ verwendet. Das Feld wird gedruckt, wobei der Separator auf „|“ gesetzt wird.
  

Ausgabe:

Wir verwenden die Funktion „ArrayPrint()“, um die Schülerinformationen anzuzeigen, nachdem wir alle notwendigen Details für jeden Schüler eingegeben haben. Das obige Bild zeigt die Standardausgabe, in der die Details ohne zusätzliche Formatierungskennzeichen angezeigt werden. Mit Hilfe des Trennzeichens „|“ werden Name, Alter, Adresse sowie die aktuelle Uhrzeit und das Datum jedes Schülers übersichtlich dargestellt. Dies ist die erste Darstellung; wir werden uns ansehen, wie man weitere Formatierungsoptionen hinzufügen kann, um die Ausgabe weiter anzupassen.  

Es ist wichtig zu wissen, dass das Hinzufügen eines bestimmten Formatierungsflags zu einer „ArrayPrint()“-Funktion den Computer veranlasst, dieses Formatierungsflag anzuwenden und die anderen zu ignorieren. Um zu veranschaulichen, wie sich das Flag „ARRAYPRINT_HEADER“ auf das Ergebnis auswirkt, fügen wir es in das Beispiel ein.

Beispiel:

ArrayPrint(Students, 0, " | ", 0, WHOLE_ARRAY,ARRAYPRINT_HEADER);

Ausgabe:

Um die Identifizierung der einzelnen Felder zu erleichtern, weist das Flag die Funktion an, Kopfzeilen ([name] [age] [address] [time]) für das Strukturarray aufzunehmen. „ARRAYPRINT_INDEX“ gehört zu den anderen Flags, die in diesem Fall absichtlich weggelassen werden, um zu verdeutlichen, wie jedes Flag für sich allein funktioniert.

In den Vergleichsbildern sehen Sie, dass sich die zweite Ausgabe von der ersten unterscheidet, da wir das Flag „ARRAYPRINT_HEADER“ eingeführt haben. Dieses Flag weist die Funktion „ArrayPrint“ an, Überschriften für jedes Feld einzufügen, um die angezeigten Informationen eindeutig zu kennzeichnen. In der zweiten Ausgabe fehlen die Indizierungsinformationen. Dies unterstreicht, dass jedes Formatierungskennzeichen unabhängig arbeitet und dass die Einbeziehung eines bestimmten Kennzeichens die Ausgabe entsprechend verändert. Um die Vielseitigkeit der Anpassung der Ausgabe an Ihre Präferenzen zu demonstrieren, werden wir auch mit verschiedenen Flag-Kombinationen experimentieren.

Bei der Arbeit mit Zeitdaten bietet die Funktion „ArrayPrint“ eine noch größere Vielseitigkeit. Flags wie „ARRAYPRINT_MINUTES“ und „ARRAYPRINT_SECONDS“ können verwendet werden, um das Zeitformat anzupassen. Mit diesen Flags können Sie den Detaillierungsgrad der angezeigten Zeitinformationen anpassen und so die Anzeige nach Ihren Wünschen gestalten. Wenn Sie sich für das Flag „ARRAYPRINT_MINUTES“ entscheiden, gibt die Funktion nur die aktuellen Stunden und Minuten aus und lässt das Datum und die Sekunden weg. Mit dem Flag „ARRAYPRINT_SECONDS“ hingegen wird die Ausgabe weiter verfeinert und es werden nur die Stunden, Minuten und Sekunden angezeigt. Diese Flags ermöglichen eine granulare Kontrolle über die Zeitdarstellung und stellen sicher, dass Ihre Ausgabe genau Ihren Anforderungen entspricht, ohne unnötige Details zu enthalten.

Beispiel:

ArrayPrint(Students, 0, " | ", 0, WHOLE_ARRAY,ARRAYPRINT_MINUTES);

Ausgabe:

Diese Flags schließen sich nicht gegenseitig aus. Sie können mehrere Flags kombinieren, um die Ausgabe noch präziser zu gestalten. Wenn Sie z. B. die beiden Flags ARRAYPRINT_HEADER und ARRAYPRINT_MINUTES zusammen anwenden, schließt die Funktion Spaltenüberschriften ein und stellt die Uhrzeit in einem Format dar, das nur die aktuelle Stunde und die Minuten anzeigt.

Beispiel:

ArrayPrint(Students,0," | ",0,WHOLE_ARRAY,ARRAYPRINT_HEADER | ARRAYPRINT_MINUTES);

Ausgabe:

Dies zeigt, wie die Flags nahtlos zusammenarbeiten, um ein individuelles und informatives Ergebnis zu erzielen.

2. ArrayInsert

Eine nützliche Methode zum Einfügen von Elementen aus einem Array in ein anderes ist die Verwendung der Funktion „ArrayInsert()“. Durch das Anordnen von Elementen aus dem Quell-Array an einer bestimmten Stelle können Sie die Größe des Ziel-Arrays erhöhen. Stellen Sie sich vor, Sie fügen ein neues Teil in ein bestehendes Puzzle ein, ohne das Gesamtbild des Puzzles zu stören.

Unterschied zwischen ArrayInsert und ArrayCopy:

Der Hauptunterschied zwischen „ArrayInsert()“ und „ArrayCopy()“ besteht darin, wie sie mit bereits vorhandenen Elementen umgehen. „ArrayCopy()“ kann das ursprüngliche Array verändern, indem es die Elemente an einer bestimmten Position durch Elemente eines anderen Arrays ersetzt. „ArrayInsert()“ hingegen bewahrt die Struktur und Reihenfolge des Arrays, indem es die aktuellen Elemente verschiebt, um Platz für die neuen zu schaffen. Im Wesentlichen bietet „ArrayInsert()“ eine vielseitige Methode zur Manipulation von Arrays in MQL5, ähnlich wie das Hinzufügen eines neuen Elements zu einer Sequenz, ohne dass sich andere Teile bewegen müssen. Wenn Sie diese Unterscheidung verstehen, können Sie Array-Operationen bei Ihren Programmieraufgaben präzise handhaben.

Beachten Sie, dass „ArrayInsert()“ bei statischen Arrays keine Elemente aus dem Quellarray in das Zielarray einfügt, wenn die Anzahl der einzufügenden Elemente gleich oder größer als die Arraygröße ist. Unter diesen Umständen kann das Einfügen nur erfolgen, wenn es bei Index 0 des Zielfeldes beginnt. In diesen Fällen wird das Zielfeld praktisch vollständig durch das Quellfeld ersetzt.

Analogie

Stellen Sie sich vor, Sie haben zwei Sätze von Bausteinen (Arrays), jeder mit seiner eigenen einzigartigen Anordnung. Nehmen wir an, Sie möchten diese Sets kombinieren, ohne die bestehenden Strukturen zu verändern. „ArrayInsert()“ ist wie ein magisches Werkzeug, mit dem Sie neue Blöcke aus einem Satz an einer bestimmten Stelle in den anderen Satz einfügen und so die gesamte Sammlung erweitern können.

Nun wird „ArrayInsert()“ mit „ArrayCopy()“ verglichen: Wenn Sie „ArrayCopy()“ verwenden, ist es ein bisschen so, als würden Sie die ursprüngliche Menge neu anordnen, indem Sie einige Blöcke durch neue Blöcke aus einer anderen Menge ersetzen. Auf der anderen Seite ist „ArrayInsert()“ etwas heikler. Sie sorgt dafür, dass die bestehende Ordnung erhalten bleibt, indem sie Blöcke verschiebt, um Platz für die Neuankömmlinge zu schaffen. Es ist, als hätte man einen akribischen Assistenten, der genau weiß, wo jeder Block platziert werden muss, damit das ursprüngliche Design des Sets erhalten bleibt.

Für statische Sets (Arrays) gibt es eine wichtige Regel. Wenn die Anzahl der neuen Blöcke zu groß ist, als dass der Satz sie verarbeiten könnte, wird „ArrayInsert()“ sie nicht einfügen. Wenn Sie jedoch den Einfügevorgang ganz am Anfang des Satzes (Index 0) beginnen, kann er effektiv den gesamten Satz durch die neuen Blöcke ersetzen. Das Verständnis dieser Konzepte hilft Ihnen, ein Meister in der Welt der MQL5-Programmierung zu werden!

Syntax:

ArrayInsert(DestinationArray[],SourceArray[],DestinationIndexStart,SourceIndexStart,count);

Parameter:

• DestinationArray[]: Das Array, das Elemente aus dem Quell-Array erhält und in dieses eingefügt wird.
  
• SourceArray[]: Das Feld, das in das Zielfeld eingefügt werden soll, wird als Quellfeld bezeichnet.
  
• DestinationIndexStart: Der Index, bei dem das Einfügen im Zielfeld beginnt.
  
• SourceIndexStart: Der Index innerhalb des Quellarrays, der verwendet wird, um Elemente zum Einfügen zu kopieren.
  
• Count: Die Anzahl der Elemente, die aus dem Quell-Array in das Ziel-Array eingefügt werden sollen.
  

Beispiel:

void OnStart()
  {

// Declare two dynamic arrays
   int SourceArray[];
   int DestinationArray[];

// Resizing the dynamic arrays to have 5 elements each
   ArrayResize(SourceArray, 5);
   ArrayResize(DestinationArray, 5);

// Assigning values to dynamic array elements
   SourceArray[0] = 1;
   SourceArray[1] = 3;
   SourceArray[2] = 5;
   SourceArray[3] = 7;
   SourceArray[4] = 9;

// Assigning different values to DestinationArray
   DestinationArray[0] = 15;
   DestinationArray[1] = 20;
   DestinationArray[2] = 25;
   DestinationArray[3] = 30;
   DestinationArray[4] = 35;

// Print the elements of SourceArray before ArrayInsert/ArrayCopy
   Print("Elements of SourceArray before ArrayInsert/ArrayCopy: ");
   ArrayPrint(SourceArray, 2, " ", 0, WHOLE_ARRAY);

// Print the elements of DestinationArray before ArrayInsert/ArrayCopy
   Print("Elements of DestinationArray before ArrayInsert/ArrayCopy: ");
   ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

// Using ArrayInsert to insert SourceArray into DestinationArray at index 2
   ArrayInsert(DestinationArray, SourceArray, 2, 0, WHOLE_ARRAY);

// Print the modified DestinationArray after ArrayInsert
   Print("Elements of DestinationArray after using ArrayInsert: ");
   ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

// Reset DestinationArray to demonstrate ArrayCopy
   ArrayFree(DestinationArray);
   ArrayResize(DestinationArray, 5);

   DestinationArray[0] = 15;
   DestinationArray[1] = 20;
   DestinationArray[2] = 25;
   DestinationArray[3] = 30;
   DestinationArray[4] = 35;

// Using ArrayCopy to copy elements from SourceArray to DestinationArray
   ArrayCopy(DestinationArray, SourceArray, 2, 0, WHOLE_ARRAY);

// Print the modified DestinationArray after ArrayCopy
   Print("Elements of DestinationArray after using ArrayCopy: ");
   ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

  }

Erläuterung:

int SourceArray[];
int DestinationArray[];

• Es werden hier die zwei dynamische Arrays „SourceArray“ und „DestinationArray“ deklariert. Ganzzahlige Werte werden in diesen Arrays gespeichert.
  

ArrayResize(SourceArray, 5);
ArrayResize(DestinationArray, 5);

• Die dynamischen Arrays werden durch diese Zeilen auf fünf Elemente pro Stück verkleinert. Hierfür wird die Funktion „ArrayResize()“ verwendet.
  

SourceArray[0] = 1;
SourceArray[1] = 3;
SourceArray[2] = 5;
SourceArray[3] = 7;
SourceArray[4] = 9;

• Die „SourceArray“-Elemente werden mit Werten versehen.
  

DestinationArray[0] = 15;
DestinationArray[1] = 20;
DestinationArray[2] = 25;
DestinationArray[3] = 30;
DestinationArray[4] = 35;

• Den „DestinationArray“-Elementen werden Werte zugewiesen.
  

Print("Elements of SourceArray before ArrayInsert/ArrayCopy: ");
ArrayPrint(SourceArray, 2, " ", 0, WHOLE_ARRAY);

• In dieser Zeile wird die Funktion „ArrayPrint()“ verwendet, um die Elemente von „SourceArray“ zu drucken, nachdem eine Meldung auf der Konsole ausgegeben wurde. Als Trennzeichen, Separator, wird ein Leerzeichen verwendet, und im Format werden zwei Dezimalstellen angezeigt.
  

Print("Elements of DestinationArray before ArrayInsert/ArrayCopy: ");
ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

• Ähnlich wie in der vorherigen Zeile wird hier eine Meldung und dann die Elemente von „DestinationArray“ ausgegeben.
  

ArrayInsert(DestinationArray, SourceArray, 2, 0, WHOLE_ARRAY);

• Diese Zeile fügt die Elemente von „SourceArray“ in „DestinationArray“ ein, beginnend bei Index 2 unter Verwendung der Funktion „ArrayInsert()“.
  

Print("Elements of DestinationArray after using ArrayInsert: ");
ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

• Nach der Operation „ArrayInsert()“ wird eine Meldung ausgegeben, gefolgt von den geänderten Elementen von „DestinationArray“.
  

ArrayFree(DestinationArray);
ArrayResize(DestinationArray, 5);

• Mit diesen Zeilen wird die Größe von „DestinationArray“ so geändert, dass es wieder fünf Elemente enthält, nachdem der Speicher freigegeben wurde.
  

DestinationArray[0] = 15;
DestinationArray[1] = 20;
DestinationArray[2] = 25;
DestinationArray[3] = 30;
DestinationArray[4] = 35;

• Den „DestinationArray“-Elementen werden wieder Werte zugewiesen.
  

ArrayCopy(DestinationArray, SourceArray, 2, 0, WHOLE_ARRAY);

• Diese Zeile verwendet die Funktion ArrayCopy, um Elemente aus SourceArray in DestinationArray zu kopieren, beginnend bei Index 2.
  

Print("Elements of DestinationArray after using ArrayCopy: ");
ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

• Dies gibt eine Meldung und dann die geänderten Elemente von „DestinationArray“ nach der Operation „ArrayCopy()“ aus.

Ausgabe:

Das Ziel dieses Codebeispiels ist es, die Unterschiede zwischen den MQL5-Funktionen „ArrayInsert()“ und „ArrayCopy()“ zu demonstrieren. Obwohl die Manipulation von Array-Elementen eine häufige Anwendung für beide Funktionen ist, sind ihre Funktionen unterschiedlich. In diesem Beispiel werden zwei dynamische Arrays - „SourceArray“ und „DestinationArray“ - verwendet. Vor der Durchführung von Operationen zeigt das Skript die in diesen Arrays enthaltenen Elemente an. Zum Einfügen von Elementen aus dem „SourceArray“ an bestimmten Stellen im „DestinationArray()“ wird dann ArrayInsert verwendet. Danach werden die Arrays zurückgesetzt und die Elemente aus „SourceArray“ mit „ArrayCopy()“ in „DestinationArray()“ kopiert. Ihre Handlungen sind der Punkt, an dem sie am meisten voneinander abweichen: Beim Einfügen von Elementen an einer bestimmten Position in das Ziel-Array verschiebt „ArrayInsert()“ die vorhandenen Elemente, um Platz für die neuen Elemente zu schaffen. Sie ist nützlich, um Elemente an den gewünschten Index zu setzen. Mit „ArrayCopy()“ werden Elemente aus dem Quell-Array kopiert und durch eventuell vorhandene Elemente im Ziel-Array ersetzt. Effizientes Kopieren von Elementen zwischen Arrays ohne Beeinträchtigung der bereits gesetzten Werte.

3. ArraySize

Die MQL5-Funktion „ArraySize()“ dient dazu, festzustellen, wie viele Elemente in einem eindimensionalen Array enthalten sind. Die Rückgabe einer ganzen Zahl, die die Gesamtzahl der Elemente innerhalb des angegebenen Arrays darstellt, vereinfacht die Bestimmung der Größe eines Arrays.

Analogie

Angenommen, Sie haben ein Bücherregal voller verschiedener Bücher, von denen jedes ein Element in einem Array darstellt. Wie ein Bibliothekar sagt Ihnen die Funktion „ArraySize()“ die genaue Anzahl der Bücher in Ihrem Regal. In ähnlicher Weise können Sie Ihre Daten effektiver verwalten und anordnen, indem Sie „ArraySize()“ verwenden, das Ihnen, wenn es auf ein Array angewendet wird, die Gesamtzahl der darin enthaltenen Elemente angibt. Programmierer können es als nützliches Werkzeug verwenden, um die Größe ihrer Arrays zu verstehen und sicherzustellen, dass sie die richtige Anzahl von „Büchern“ für ihre Codierungsbemühungen haben.

Syntax:

ArraySize( array[]);

Parameter:

• array[]: Mit diesem Parameter wird das Array angegeben, für das Sie die Größe ermitteln möchten.
  

Beispiel:

void OnStart()
  {

// Declare an array
   int array[5];

// Get the size of the array using ArraySize
   int arraySize = ArraySize(array);

// Print the array size
   Print("The size of array is: ", arraySize); // Output will be 5

  }

Erläuterung:

„int array[5];“

• In dieser Zeile wird ein Integer-Array mit dem Namen „array“ und einer Größe von „5“ deklariert.
  

„int arraySize = ArraySize(array);“

• Diese Zeile erstellt eine neue Integer-Variable namens „arraySize“ und setzt ihren Wert mit dem Zuweisungsoperator „=“ auf das Ergebnis von „ArraySize“ (array). Da die Größe eines Arrays immer eine ganze Zahl ist, wird der Typ „int“ verwendet. Die Funktion, die MQL5 zur Verfügung stellt, um die Größe eines Arrays zu bestimmen, heißt „ArraySize“ (Großbuchstaben), und die Variable, die wir zum Speichern des Ergebnisses deklariert haben, heißt „arraySize“ (Kleinbuchstaben). Die Groß- und Kleinschreibung in Programmiersprachen ist zu beachten. Der Großbuchstabe ArraySize bezeichnet die integrierte Array-Funktion, während der Kleinbuchstabe arraySize unsere spezielle Variable kennzeichnet.
  

„Print("The size of array is: ", arraySize);“:

• Diese Zeile verwendet die Funktion „Print“, um eine Nachricht auf der Konsole auszugeben. Sie zeigt die Größe des Arrays an, die von der Variable „arraySize“ abgeleitet ist.
  

Sie müssen sich Zeit nehmen und die Feinheiten jeder Funktion lernen, die wir auf unserem Weg in die erstaunliche Welt der MQL5-Programmierung entdecken. Es ist vergleichbar mit dem Erlernen des Umgangs mit Werkzeugen in einer Handwerkerwerkstatt, um Funktionen wie ArraySize, ArrayInsert und ArrayPrint zu verstehen; jede hat eine spezifische Verwendung. Nehmen Sie sich Zeit, um die Feinheiten zu lernen und zu verstehen; überstürzen Sie den Prozess nicht. Die komplexeren Ideen, die wir in späteren Artikeln behandeln, werden diese Funktionen als Grundlage haben.

4. ArrayRange

Die Funktion „ArrayRange()“ in der MQL5-Programmierung ist wichtig, um die Anzahl der Elemente in einer bestimmten Dimension eines mehrdimensionalen Arrays zu ermitteln. Es ist ein nützliches Werkzeug für Entwickler, die mit komplexen Arrays arbeiten, und gibt ihnen genaue Informationen darüber, wie viele Elemente sich in einer bestimmten Ebene oder Dimension in einem mehrdimensionalen Array befinden. Ohne sich mit der Komplexität der Ermittlung der Gesamtzahl der Elemente in allen Dimensionen befassen zu müssen, bietet diese Funktion durch die Konzentration auf eine bestimmte Dimension tiefgreifende Einblicke.

Unterschied zwischen ArrayRange und ArraySize

Unterscheiden wir nun zwischen „ArraySize()“ und „ArrayRange()“. Obwohl sie beide Einblicke in Array-Dimensionen bieten, sind die jeweiligen Anwendungsbereiche der Funktionen unterschiedlich. Die Gesamtanzahl der Elemente eines eindimensionalen Arrays kann mit „ArraySize()“ ermittelt werden.  

Eindimensionale und mehrdimensionale Arrays unterscheiden sich voneinander in der Art und Weise, wie sie Daten anordnen und strukturiert sind. Eine einfache Liste, deren Elemente in einer einzigen Zeile angeordnet sind, entspricht einem eindimensionalen Array. Der Zugriff auf die Elemente erfolgt durch Verweis auf ihre Position in dieser linearen Struktur.

Dennoch fügen mehrdimensionale Arrays weitere Strukturebenen hinzu. Mit ihren in Zeilen und Spalten angeordneten Bestandteilen ähneln sie Matrizen oder Tabellen. Die Zeilen- und Spaltenindizes müssen angegeben werden, um auf Elemente in einem mehrdimensionalen Array zuzugreifen, was eine strukturiertere Methode der Datenorganisation und -abfrage bietet. Eindimensionale Arrays sind im Wesentlichen einfache, lineare Sequenzen, während mehrdimensionale Arrays die Komplexität erhöhen, indem sie die Elemente eher wie ein Gitter anordnen.

Analogie

Stellen Sie sich vor, Sie haben ein großes Bücherregal, das ein mehrdimensionales Feld darstellt, wobei jedes Regal eine andere Dimension hat. Die Funktion „ArrayRange()“ in MQL5 ist wie ein magisches Vergrößerungsglas, mit dem Sie sich auf ein bestimmtes Regal konzentrieren und die genaue Anzahl der Bücher (Elemente) in diesem Regal anzeigen können. Dieses Werkzeug ist unglaublich praktisch, wenn man mit einer komplexen Bibliothek von Informationen zu tun hat.

Wir wollen nun „ArraySize()“ und „ArrayRange()“ gegenüberstellen. Sollten die Bücher linear organisiert sein, ähnlich einem eindimensionalen Array, dann bezeichnet „ArraySize()“ die Gesamtzahl der Bücher im gesamten Bücherregal. Alternativ können Sie auch „ArrayRange()“ verwenden, um einen bestimmten Bereich des Bücherregals zu vergrößern und so die Anzahl der dort befindlichen Bücher genau zu ermitteln.

Syntax:

ArrayRange(array[], dimensionIndex);

Parameter:

• array[]: Das Array, dessen Bereich Sie überprüfen möchten.
• dimensionIndex: Der Dimensionsindex, beginnend bei 0, für den der Bereich ermittelt werden muss.

Beispiel:

void OnStart()
  {

// Declare a three-dimensional array
   double my3DArray[][2][4];

// Get the range of the first dimension (index 0)
   int dimension1Index = ArrayRange(my3DArray, 0);

// Get the range of the second dimension (index 1)
   int dimension2Index = ArrayRange(my3DArray, 1);

// Get the range of the third dimension (index 2)
   int dimension3Index = ArrayRange(my3DArray, 2);

   Print("Number of elements in dimension 1: ", dimension1Index);
   Print("Number of elements in dimension 2: ", dimension2Index);
   Print("Number of elements in dimension 3: ", dimension3Index);

  }

Erläuterung:

double my3DArray[][2][4];

• In dieser Zeile wird ein dreidimensionales Array namens „my3DArray“ deklariert.

int dimension1Index = ArrayRange(my3DArray, 0);

• In diesem Fall wird der Bereich (Anzahl der Elemente) in der ersten Dimension von my3DArray (Index 0) mit der Funktion „ArrayRange()“ ermittelt. Die Variable „dimension1Index“ enthält das Ergebnis.
  

int dimension2Index = ArrayRange(my3DArray, 1);

• In ähnlicher Weise erhält und speichert diese Zeile in der Variablen „dimension2Index“ den Bereich der zweiten Dimension (Index 1) des „my3DArray“.
  

int dimension3Index = ArrayRange(my3DArray, 2);

• Diese Zeile weist den Wert der Variablen „dimension3Index“ dem Bereich der dritten Dimension (Index 2) des „my3DArray“ zu.
  

Print("Number of elements in dimension 1: ", dimension1Index);
Print("Number of elements in dimension 2: ", dimension2Index);
Print("Number of elements in dimension 3: ", dimension3Index);

• Abschließend werden die Ergebnisse und die Anzahl der Elemente in jeder Dimension mit der Funktion Drucken angezeigt. Die erste, zweite und dritte Dimension des dreidimensionalen Feldes sind in den gedruckten Informationen enthalten.
  

Ausgabe:

5. ArrayRemove

Die Funktion „ArrayRemove()“ ist ein effektives Werkzeug, mit dem Programmierer bestimmte Elemente aus einem Array entfernen können. Die Größe und Struktur des Arrays wird automatisch an den Löschvorgang angepasst, sodass ein nahtloser Löschvorgang gewährleistet ist. Entwickler sind bei der Bearbeitung von Arrays flexibel, da sie den Startindex und die Anzahl der Elemente, die sie entfernen möchten, angeben können. Bei der Arbeit mit Arrays, die als Reaktion auf sich ändernde Programmbedingungen dynamisch geändert werden müssen, ist diese Funktion besonders hilfreich.

Das Verhalten von „ArrayRemove()“ hängt jedoch davon ab, ob statische oder dynamische Arrays verwendet werden. Bei dynamischen Arrays sorgt die Funktion für einen rationellen Entfernungsprozess, indem sie das angegebene Element oder die angegebenen Elemente effektiv entfernt und die Array-Größe reibungslos anpasst. Auf der anderen Seite eliminiert „ArrayRemove()“ die angegebenen Elemente und behält die ursprüngliche Array-Größe bei, wenn mit statischen Arrays gearbeitet wird. Um jedoch die feste Natur statischer Arrays zu überwinden, dupliziert die Funktion die Elemente, die nach dem Ende des Arrays kommen, um die leeren Stellen zu füllen. Diese Methode ermöglicht das Entfernen von Elementen, während die Größe beibehalten wird, wodurch „ArrayRemove()“ ein differenzierteres Verständnis verschiedener Array-Szenarien erhält. Während wir diesen Abschnitt durcharbeiten, werden uns weitere Beispiele und Einblicke helfen, ein tieferes Verständnis von „ArrayRemove()“ zu erlangen und wie es in verschiedenen Array-Szenarien funktioniert.

Analogie

Betrachten Sie unser Array als ein Bücherregal, in dem einzelne Bücher Informationen darstellen. Jetzt gibt uns MQL5 ein einzigartiges Werkzeug, das einem Bücherregal-Organizer ähnelt und „ArrayRemove()“ heißt. Wir können bestimmte Bücher aus unserem Bücherregal entfernen und die verbleibenden Bücher ordentlich anordnen, um eventuelle Lücken zu füllen, indem wir diesen Organizer verwenden.

Stellen Sie sich vor, Sie haben ein dynamisches Bücherregal, in das Sie problemlos Bücher hinzufügen oder entfernen können. In diesem Fall passt der Organizer das Regal nach der Entnahme von Büchern ohne Probleme an. Wenn Ihr Bücherregal jedoch eher einer Anzeige mit fester Größe gleicht, bei der Sie die Größe nicht ändern können (statisches Array), kann „ArrayRemove()“ bei der Arbeit mit statischen Arrays die Größe des Regals nicht ändern und dupliziert daher geschickt das Buch am Ende des Arrays, um den leeren Platz zu füllen. Es ist, als würde man eine Kopie der letzten Bücher im Regal machen und sie in die Lücke stellen, die das entfernte Buch hinterlassen hat. Auf diese Weise behält das Bücherregal mit fester Größe seine Vollständigkeit, und es wird kein Platz verschwendet.

Wenn Sie also ein Buch aus der Mitte Ihres Bücherregals entfernen, sorgt „ArrayRemove()“ dafür, dass das Ende des Regals kopiert wird, um die Lücke zu füllen, wobei die Struktur des Arrays erhalten bleibt. Dies kann besonders praktisch sein, wenn Sie eine bestimmte Anzahl von Fächern (Elementen) beibehalten müssen, denn so können Sie Ihr Bücherregal aufräumen, ohne seine Größe zu verändern.

 

Syntax:

ArrayRemove(array[],start_index,count);

Parameter:

• array[]:Dies ist das Array, dessen Elemente eliminiert werden sollen. Die Ablagefläche oder das Bücherregal ist der Ort, an dem Sie Änderungen vornehmen möchten.
  
• start_index: Er gibt den Anfangspunkt der Entfernung innerhalb des Arrays an. Wenn Sie z. B. Bücher ausschließen möchten, die im dritten Regal beginnen, setzen Sie den Index auf 3.
  
• count: Die Anzahl der Elemente, die aus dem Array entfernt werden sollen. Wenn Sie drei Bücher entfernen möchten, setzen Sie die Anzahl auf 3.
  

Beispiel:

void OnStart()
  {

// Declare fixed-size array
   int fixedSizeArray[5] = {11, 13, 17, 21, 42};

// Declare dynamic array
   int dynamicArray[];
   ArrayResize(dynamicArray, 5);
   dynamicArray[0] = 11;
   dynamicArray[1] = 13;
   dynamicArray[2] = 17;
   dynamicArray[3] = 21;
   dynamicArray[4] = 42;

// Print initial arrays
   Print("Initial fixedSizeArray: ");
   ArrayPrint(fixedSizeArray, 0, " ", 0, WHOLE_ARRAY);

   Print("Initial dynamicArray: ");
   ArrayPrint(dynamicArray, 0, " ", 0, WHOLE_ARRAY);

// Remove two elements at index 2 from both arrays
   ArrayRemove(fixedSizeArray, 2, 2);
   ArrayRemove(dynamicArray, 2, 2);

// Print arrays after removal
   Print("After removing 3 elements at index 2 - fixedSizeArray: ");
   ArrayPrint(fixedSizeArray, 0, " ", 0, WHOLE_ARRAY);

   Print("After removing 3 elements at index 2 - dynamicArray: ");
   ArrayPrint(dynamicArray, 0, " ", 0, WHOLE_ARRAY);

  }

Erläuterung:

// Declare fixed-size array
   int fixedSizeArray[5] = {11, 13, 17, 21, 42};

// Declare dynamic array
   int dynamicArray[];
   ArrayResize(dynamicArray, 5);
   dynamicArray[0] = 11;
   dynamicArray[1] = 13;
   dynamicArray[2] = 17;
   dynamicArray[3] = 21;
   dynamicArray[4] = 42;

• Deklariert wird erst ein statisches Integer-Array mit einer festen Größe von 5, das „fixedSizeArray“ heißt, und mit den Werte 11, 13, 17, 21 und 42 initialisiert wird.
  
• Dann wird ein ein ganzzahliges, dynamisches Array mit dem Namen „dynamicArray“ ohne Angabe einer Anfangsgröße deklariert. Mit „ArrayResize“ wird die Größe von „dynamicArray“ auf eine Größe von 5 geändert.
  

Print("Initial fixedSizeArray: ");
ArrayPrint(fixedSizeArray, 0, " ", 0, WHOLE_ARRAY);

Print("Initial dynamicArray: ");
ArrayPrint(dynamicArray, 0, " ", 0, WHOLE_ARRAY);

• Drucken der Anfangselemente von „fixedSizeArray“ und „dynamicArray“ unter Verwendung von „ArrayPrint“.
  

ArrayRemove(fixedSizeArray, 2, 2);
ArrayRemove(dynamicArray, 2, 2);

• Mit „ArrayRemove“ werden zwei Elemente aus „fixedSizeArray“ und „dynamicArray“ entfernt, beginnend bei Index 2.
  

Print("After removing 3 elements at index 2 - fixedSizeArray: ");
ArrayPrint(fixedSizeArray, 0, " ", 0, WHOLE_ARRAY);

Print("After removing 3 elements at index 2 - dynamicArray: ");
ArrayPrint(dynamicArray, 0, " ", 0, WHOLE_ARRAY);

• Nach dem Entfernen wird mit „ArrayPrint“ die Elemente von „fixedSizeArray“ und „dynamicArray“ ausgedruckt.
  

Ausgabe:

 

Die Ausgabe des angegebenen Codes ist in der obigen Abbildung zu sehen, die zeigt, wie sich die Funktion „ArrayRemove()“ sowohl bei statischen als auch bei dynamischen Arrays verhält. Beim dynamischen Array ist das Verfahren sehr einfach: Es geht nur darum, die Elemente zu löschen, die bei dem angegebenen Index angegeben sind. Um die durch das Entfernen entstandenen Leerstellen zu füllen, dupliziert die Funktion für das statische Array die Elemente, die nach dem Ende des Arrays erscheinen. Dieses subtile Verhalten demonstriert die Art und Weise, wie sich „ArrayRemove()“ an verschiedene Array-Typen anpasst.

Die Konzepte von „ArrayRemove()“ werden klarer werden, wenn wir diese Artikel durcharbeiten und zu realen Beispielen übergehen. Bitte zögern Sie nicht, weitere Fragen zu stellen; gemeinsam werden wir diese Konzepte weiter erforschen und verstehen.

6. ArraySwap

Der Zweck der Funktion „ArraySwap()“ in der MQL5-Programmierung ist es, den gesamten Inhalt zweier dynamischer Arrays zu tauschen. Alle Elemente zwischen zwei Arrays können mit Hilfe dieser Funktion leichter ausgetauscht werden. Es bietet eine einfache Möglichkeit, den gesamten Datensatz zwischen den Arrays umzuschalten, was den MQL5-Prozess der Neuanordnung von Array-Inhalten beschleunigt.

Analogie

Angenommen, Sie haben zwei Bücherregale, die mit Büchern gefüllt sind. Mit der Funktion „ArraySwap()“ können Sie jedes Buch in einem Regal gegen jedes andere Buch austauschen, ähnlich wie bei einem Zauberspruch eines Hexenmeisters. Um alle Bücher aus „Regal A“ nach „Regal B“ und alle Bücher aus „Regal B“ nach „Regal A“ zu verschieben, können Sie den „ArraySwap()“-Zauber verwenden, wenn Sie „Regal A“ mit einigen Büchern und „Regal B“ mit anderen Büchern bestückt haben. Es ist eine einfache Möglichkeit, jedes Buch in zwei Regalen umzustellen, ohne sich um bestimmte Bücher kümmern zu müssen.

Syntax:

ArraySwap(dynamic_array1, dynamic_array2);

Parameter:

Angenommen, Sie haben zwei Bücherregale, die mit Büchern gefüllt sind. Mit der Funktion „ArraySwap()“ können Sie jedes Buch in einem Regal gegen jedes andere Buch austauschen, ähnlich wie bei einem Zauberspruch eines Hexenmeisters. Um alle Bücher aus „Regal A“ nach „Regal B“ und alle Bücher aus „Regal B“ nach „Regal A“ zu verschieben, können Sie den „ArraySwap()“-Zauber verwenden, wenn Sie „Regal A“ mit einigen Büchern und „Regal B“ mit anderen Büchern bestückt haben. Es ist eine einfache Möglichkeit, jedes Buch in zwei Regalen umzustellen, ohne sich um bestimmte Bücher kümmern zu müssen.

Beispiel:

void OnStart()
  {

// Declare dynamic arrays
   int dynamic_array1[];
   int dynamic_array2[];

// Resize dynamic arrays to have 5 elements each
   ArrayResize(dynamic_array1, 5);
   ArrayResize(dynamic_array2, 5);

// Assign values to dynamic arrays
   dynamic_array1[0] = 1;
   dynamic_array1[1] = 3;
   dynamic_array1[2] = 5;
   dynamic_array1[3] = 7;
   dynamic_array1[4] = 9;

   dynamic_array2[0] = 11;
   dynamic_array2[1] = 13;
   dynamic_array2[2] = 15;
   dynamic_array2[3] = 17;
   dynamic_array2[4] = 19;

// Print initial dynamic arrays
   Print("Initial dynamic_array1: ");
   ArrayPrint(dynamic_array1, 0, " ", 0, WHOLE_ARRAY);

   Print("Initial dynamic_array2: ");
   ArrayPrint(dynamic_array2, 0, " ", 0, WHOLE_ARRAY);

// Swap the contents of dynamic_array1 and dynamic_array2
   ArraySwap(dynamic_array1, dynamic_array2);

// Print dynamic arrays after swapping
   Print("After swapping - dynamic_array1: ");
   ArrayPrint(dynamic_array1, 0, " ", 0, WHOLE_ARRAY);

   Print("After swapping - dynamic_array2: ");
   ArrayPrint(dynamic_array2, 0, " ", 0, WHOLE_ARRAY);
  }

Erläuterung:

// Declare dynamic arrays
   int dynamic_array1[];
   int dynamic_array2[];

// Resize dynamic arrays to have 5 elements each
   ArrayResize(dynamic_array1, 5);
   ArrayResize(dynamic_array2, 5);

• Die dynamischen Integer-Arrays „dynamic_array1“ und „dynamic_array2“ werden in diesen Zeilen deklariert. Die Größe jedes dynamischen Arrays wird mit der Funktion „ArrayResize“ auf 5 gesetzt.
  

// Assign values to dynamic arrays
   dynamic_array1[0] = 1;
   dynamic_array1[1] = 3;
   dynamic_array1[2] = 5;
   dynamic_array1[3] = 7;
   dynamic_array1[4] = 9;

   dynamic_array2[0] = 11;
   dynamic_array2[1] = 13;
   dynamic_array2[2] = 15;
   dynamic_array2[3] = 17;
   dynamic_array2[4] = 19;

• Diese Zeilen geben jedem Element in „dynamic_array1“ und „dynamic_array2“ einen bestimmten Wert.
  

// Print initial dynamic arrays
   Print("Initial dynamic_array1: ");
   ArrayPrint(dynamic_array1, 0, " ", 0, WHOLE_ARRAY);

   Print("Initial dynamic_array2: ");
   ArrayPrint(dynamic_array2, 0, " ", 0, WHOLE_ARRAY);

• Diese Zeilen geben die Anfangswerte von „dynamic_array1“ und „dynamic_array2“ auf der Konsole aus.
  

// Swap the contents of dynamic_array1 and dynamic_array2
   ArraySwap(dynamic_array1, dynamic_array2);

• Um den gesamten Inhalt von „dynamic_array1“ durch „dynamic_array2“ zu ersetzen, verwenden Sie die Funktion „ArraySwap()“.
  

// Print dynamic arrays after swapping
   Print("After swapping - dynamic_array1: ");
   ArrayPrint(dynamic_array1, 0, " ", 0, WHOLE_ARRAY);

   Print("After swapping - dynamic_array2: ");
   ArrayPrint(dynamic_array2, 0, " ", 0, WHOLE_ARRAY);

• Nach dem Tauschvorgang geben diese Zeilen die aktualisierten Werte von „dynamic_array1“ und „dynamic_array2“ auf der Konsole aus.
  

Ausgabe:

7. ArrayReverse

Die Elemente eines Arrays können mit der Funktion „ArrayReverse()“ neu angeordnet oder in ihrer Reihenfolge umgedreht werden. Mit Hilfe dieser Funktion können Entwickler die Elemente in der Sequenz schnell umdrehen, sodass das letzte Element das erste ist und andersherum. Dieser Vorgang bietet eine flexible und effektive Möglichkeit, die Anordnung von Elementen in Arrays zu ändern, die eine Vielzahl von Datentypen enthalten. Wenn bei der Programmierung die Reihenfolge der Elemente umgekehrt werden muss, erleichtert „ArrayReverse()“ den Prozess und führt zu einem prägnanteren, lesbaren Code.

Analogie

Stellen Sie sich ein Regal mit einer Reihe von Büchern vor, die jeweils mit einer Nummer versehen sind. Es ist, als ob diese Bücher auf magische Weise mit der Funktion „ArrayReverse()“ neu angeordnet wurden, wobei das ganz rechte Buch nun ganz links liegt und umgekehrt. Es ist eine einfache Methode, um die Reihenfolge der Bücher in Ihrem Regal zu ändern. Und nicht nur das, es funktioniert auch ähnlich in der Programmierung, wo Sie „ArrayReverse()“ verwenden können, um die Reihenfolge der Elemente in einer Liste oder einem Array umzudrehen, wobei Sie mit dem letzten Element beginnen und sich bis zum ersten Element vorarbeiten. Es ist, als würde man einen Zauberspruch rückwärts auf seine Anordnung anwenden und sie mühelos umdrehen.

Syntax:

ArrayReverse(array[], start, count);

Parameter: 

• array[]: Das Array, das Sie umkehren wollen, wird durch diesen Parameter dargestellt.
• start: Der Index innerhalb des Arrays, bei dem die Umkehrung beginnen soll.
• count: Die Anzahl der Elemente, die im Array umgedreht werden sollen.

Beispiele:

void OnStart()
  {

// Declare and initialize a 10-element array
   int array[10] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};

// Print the original array
   Print("Original Array: ");
   ArrayPrint(array, 0, " ", 0, WHOLE_ARRAY);

// Reverse the array starting from index 4
   ArrayReverse(array, 4, WHOLE_ARRAY);

// Print the array after reversal
   Print("Array after reversal from index 4: ");
   ArrayPrint(array, 0, " ", 0, WHOLE_ARRAY);

  }

Dieser Code initialisiert das Array mit den angegebenen Elementen, druckt das ursprüngliche Array aus, kehrt es ab dem Index 4 um und druckt dann das Ergebnis.

Ausgabe:

8. ArraySort

Um die Elemente eines Arrays in aufsteigender Reihenfolge zu sortieren, ist die Funktion „ArraySort()“ ein nützliches Werkzeug. Mit dieser Funktion können Sie die Elemente eines Arrays schnell sequentiell anordnen, wobei Sie mit dem kleinsten Wert beginnen und sich zum größten hocharbeiten. Diese Funktion ist besonders nützlich, wenn Sie mit Arrays arbeiten, die numerische Werte enthalten.

Analogie

Stellen Sie sich vor, Sie möchten eine Sammlung von durcheinander gewürfelten Zahlen von der kleinsten zur größten ordnen. Mit Hilfe der Funktion „ArraySort()“, die wie ein Zauberspruch funktioniert, können Sie diese Zahlen schnell in die richtige Reihenfolge bringen. Auf diese Weise können Sie die kleinsten und größten Zahlen in Ihrer Liste leicht identifizieren, indem Sie einen einzigen, einfachen Befehl verwenden, um Ihre Zahlen gut zu sortieren. Dank der Magie der Funktion „ArraySort()“ können Sie die Zahlen in einer verständlichen und strukturierten Weise sehen!

Syntax:

ArraySort(array[]); // array[] ist das Array, das in aufsteigender Reihenfolge sortiert werden soll

Beispiel:

void OnStart()
  {

// Declare an array of numbers
   double array[5] = {9.5, 2.1, 7.8, 1.3, 5.6};

// Print the array before sorting
   Print("Array before sorting: ");
   ArrayPrint(array, 1, " ", 0, WHOLE_ARRAY);

// Use ArraySort to arrange the array in ascending order
   ArraySort(array);

// Print the array after sorting
   Print("Array after sorting: ");
   ArrayPrint(array, 1, " ", 0, WHOLE_ARRAY);

  }

Auszug:

Schlussfolgerung

Wir haben nun viele der wichtigsten Ideen für die Array-Verwaltung in MQL5 behandelt, einschließlich ArrayPrint, ArrayInsert, ArraySize, ArrayRange, ArrarRemove, ArraySwap, ArrayReverse und ArraySort. Ziel ist es, im Laufe dieser Serie ein breites Spektrum an grundlegenden Ideen zu behandeln, die als Grundlage für die Automatisierung von Handelsstrategien dienen. Es ist von entscheidender Bedeutung, diese Array-Funktionen zu verstehen, insbesondere bei der Arbeit mit historischen Daten zur Erstellung von Expertenberatern. Unabhängig von der Erfahrungsstufe verspreche ich, dass jeder Leser diese grundlegenden Konzepte beherrscht und damit den Grundstein für eine lohnende Reise in die MQL5-Programmierung und den algorithmischen Handel legt. 

Zum Abschluss dieses Artikels fordere ich jeden auf, sich jeder Idee mit Geduld und Neugier zu nähern, denn diese grundlegenden Bausteine werden in zukünftigen Artikeln wichtig sein und die Entwicklung zuverlässiger automatisierter Handelssysteme sowohl lohnend als auch zugänglich machen. Ihr Verständnis hat für mich oberste Priorität, also zögern Sie bitte nicht, sich an mich zu wenden und Fragen zu stellen, wenn Sie Unterstützung oder Klarstellungen zu irgendeinem Teil dieses Artikels benötigen. Im nächsten Artikel werden wir in einer ausführlichen Videositzung alle Aspekte der in Teil 5 und 6 besprochenen Array-Funktionen behandeln. Um alle verbleibenden Zweifel zu zerstreuen, bietet dieses Video ein visuelles Handbuch, um Ihr Verständnis für diese entscheidenden MQL5-Programmierideen zu verbessern.