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

Einführung

Teil 5 unserer Serie führt Sie in die faszinierende Welt von MQL5 ein, speziell für Anfänger, die eine sanfte Einführung in die Feinheiten der Array-Funktionen suchen. Dieser Abschnitt zielt darauf ab, die Missverständnisse auszuräumen, die häufig mit Array-Funktionen verbunden sind, um zu gewährleisten, dass jede Codezeile nicht nur verstanden, sondern auch gründlich nachvollzogen wird. Unabhängig von der Erfahrung im Programmieren glaube ich aufrichtig daran, dass jeder die Möglichkeit haben sollte, die Sprache MQL5 kennenzulernen, und deshalb werde ich mich immer dafür einsetzen, ein integratives Umfeld zu schaffen.

In diesem Artikel geht es in erster Linie um Einfachheit und Klarheit. Ich möchte eine Anlaufstelle für Menschen sein, die neugierig auf das Programmieren und das damit verbundene Neuland sind. Auch wenn sie anfangs verwirrend sein können, möchte ich Sie Zeile für Zeile durch die einzelnen Array-Funktionen führen, damit Sie eine unterhaltsame und lehrreiche Lernerfahrung machen. Gemeinsam werden wir die Rätsel rund um die Array-Funktionen lösen und Ihnen das nötige Wissen vermitteln, um sich in der komplexen Welt des algorithmischen Handels erfolgreich zurechtzufinden. Dies ist nicht nur ein Artikel, sondern eine Einladung, sich auf eine erstaunliche Reise der Codierungstransformation zu begeben. 

Aber das ist noch nicht alles. Über den Code hinaus hoffen wir, eine Gemeinschaft zu schaffen, in der sowohl Programmieranfänger als auch erfahrene Programmierer zusammenkommen können, um Ideen auszutauschen, Fragen zu stellen und die Teamarbeit zu fördern. Dies ist eine Einladung zu einem lebensverändernden Programmierabenteuer, nicht nur ein Artikel. Grüße aus Teil 5, wo Wissen und Zugänglichkeit aufeinander treffen, und jeder, der programmiert, geschätzt wird. Viel Spaß beim Programmieren!

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

• ArrayBsearch
  
• ArrayResize
  
• ArrayCopy
  
• ArrayCompare
  
• ArrayFree
• ArraySetAsSeries
• ArrayGetAsSeries
  
• ArrayIsSeries
  
• ArrayInitialize
  
• ArrayFill
  
• ArrayIsDynamic
  
• ArrayMaximum
  
• ArrayMinimum

Bevor wir zu Teil 5 kommen, möchte ich Ihnen ein Video zeigen, das die Erkenntnisse aus Teil 4 zusammenfasst. Dies ist eine Zusammenfassung, um sicherzustellen, dass jeder über die Situation Bescheid weiß. Lassen Sie uns weiterhin MQL5-Arrays für absolute Neulinge leichter verständlich machen und gleichzeitig eine unterstützende und wissensvermittelnde Gemeinschaft aufbauen. Begleiten Sie mich auf dieser Codierungsreise!

1. ArrayBsearch

Sie können die Funktion „ArrayBsearch()“ für Arrays verwenden, die in aufsteigender Reihenfolge angeordnet sind. Dies schlägt vor, die Werte im Array vom kleinsten zum größten Wert in aufsteigender Reihenfolge zu sortieren. Die Funktion verwendet eine binäre Suchtechnik, die für sortierte Arrays zuverlässige Ergebnisse liefert, aber möglicherweise nicht gut für unsortierte oder zufällig geordnete Arrays funktioniert. Um eine effektive und genaue Suche durchzuführen, müssen Sie daher sicherstellen, dass Ihr Array korrekt sortiert ist, bevor Sie „ArrayBsearch()“ verwenden.

Analogie

Angenommen, Sie haben eine Reihe von Zahlen, die in einer bestimmten Reihenfolge von der kleinsten zur größten sortiert sind. Stellen Sie sich vor, Sie wollen in dieser sortierten Liste nach einer bestimmten Zahl suchen, z. B. 30. Anstatt jede Nummer manuell durchzugehen, funktioniert die Funktion „ArrayBsearch()“ wie ein intelligenter Berater. Es teilt Ihnen mit, dass sich die Nummer 30 an Position 2 (Index 2) in der Liste befindet, und leitet Sie schnell zu der entsprechenden Stelle weiter. Es ist, als hätte man einen hilfreichen Freund, der die Suche methodisch vorantreibt!

Syntax:

int ArrayBsearch(array[],value);

Erläuterung:

• „int“: Dies ist der Datentyp, den die Funktion zurückgibt. In diesem Fall handelt es sich um eine Ganzzahl, die den Index des gefundenen oder vorgeschlagenen Wertes im Array darstellt.
• „ArrayBsearch“: Dies ist der Name der Funktion
• „array[]“: Das zu durchsuchende Array.
• „value“: Dies ist der Wert, nach dem im Array gesucht werden soll.

Beispiel:

void OnStart()
  {

// Declare an array of sorted numbers
   double sortedArray[] = {10, 20, 30, 40, 50};

// Value to search for
   double searchValue = 30;

// Call ArrayBsearch function
   int resultIndex = ArrayBsearch(sortedArray, searchValue);

// Print out the index of 30 in the array
   Print("Found the resultIndex at index ", resultIndex); // The output will be index 2

  }

Erläuterung:

„double sortedArray[] = {10, 20, 30, 40, 50};“:

• Diese Zeile deklariert das Array mit dem Namen „sortedArray“, das die sortierten Zahlen {10, 20, 30, 40, 50} enthält.

„double searchValue = 30;“:

• Diese Zeile setzt den „searchValue“ auf 30, die Zahl, die wir im Array finden wollen.

  „int resultIndex = ArrayBsearch(sortedArray, searchValue);“:

• Diese Zeile ruft die Funktion „ArrayBsearch()“ auf und übergibt „sortedArray“ und „searchValue“ als Argumente. Sie gibt den Index zurück, in dem der „searchValue“ gefunden wird, oder den vorgeschlagenen Einfügepunkt, wenn der Wert nicht vorhanden ist.

“Print("Found the resultIndex at index ", resultIndex);“:

• Diese Zeile gibt das Ergebnis der Suche aus. Wenn „searchValue“ gefunden wird, wird der Index gedruckt; andernfalls wird die vorgeschlagene Einfügestelle gedruckt.

In diesem Beispiel ist „sortedArray“ das Array, in dem wir suchen, und „searchValue“ ist der Wert, den wir in dem Array finden wollen. Die Funktion gibt den Index zurück, bei dem der Wert gefunden wurde, und druckt das Ergebnis aus.

2. ArrayResize

Mit der MQL5-Funktion „ArrayResize()“ können Sie die Größe eines dynamischen Arrays ändern, während das Programm läuft. Dynamische Arrays erlauben Größenanpassungen während der Programmausführung, im Gegensatz zu statischen Arrays, deren Größe vorgegeben ist. Mit anderen Worten: „ArrayResize()“ ist ein Werkzeug, mit dem Sie während der Ausführung Ihres Programms die Größe eines dynamischen Arrays ändern oder erweitern können, je nachdem, was Sie gerade benötigen. Es erhöht die Flexibilität, Daten während der Laufzeit effektiver zu verarbeiten.

Die statischen Arrays der Programmierung haben eine feste Größe, die bei der Kompilierung des Programms festgelegt wird. Die Anzahl der Elemente bleibt konstant, da die Größe festgelegt ist und während der Laufzeit nicht verändert werden kann. Der für diese Arrays zugewiesene Speicherplatz richtet sich nach der Größe, mit der sie deklariert werden. Ein Array mit fünf Elementen würde beispielsweise immer Platz für fünf Elemente bieten.

Beispiel:

// Static array declaration
int staticArray[5] = {1, 2, 3, 4, 5};

Umgekehrt bieten dynamische Arrays Flexibilität, da die Größe während der Programmausführung angepasst oder festgelegt werden kann. Diese Arrays werden zunächst ohne Größe deklariert, und in MQL5 können Funktionen wie „ArrayResize()“ verwendet werden, um die Speicherzuweisung zu ändern. Wenn die Größe einer Datenstruktur flexibel sein muss, um eine unterschiedliche Anzahl von Elementen während der Programmausführung aufzunehmen, sind dynamische Arrays besonders hilfreich.

Beispiel:

// Dynamic array declaration
int dynamicArray[];

Analogie

Nehmen wir an, Sie hast einen magischen Rucksack (Array), in dem sich eine Menge Spielzeug (Elemente) befindet. Wenn Sie sich auf ein Abenteuer begibst, können Sie die Anzahl der Spielsachen wählen, die ein statischer Rucksack aufnehmen kann, und das bleibt während der gesamten Reise so. Wenn Sie mehr Spielzeug mitnehmen wollen, als er fassen kann, haben Sie ein Problem.

Ein dynamischer Rucksack kann als etwas Besonderes angesehen werden, das mit zusätzlichen Spielsachen oder Spielsachen, die man mit Freunden teilen möchte, erweitert werden kann. Um die Größe Ihres Rucksacks zu ändern und so viele Spielsachen zu transportieren, wie Sie für Ihr magisches Abenteuer brauchen, nutzen Sie „ArrayResize()“ wie einen Zauberspruch.

Sie können die Größe des dynamischen Rucksacks unterwegs ändern, sind also nicht auf ihn beschränkt. Diese Anpassungsfähigkeit trägt dazu bei, dass Ihre magische Reise immer voller Überraschungen und Aufregung ist, egal ob Sie neue Spielsachen finden oder sie mit anderen teilen möchten! Es ist vergleichbar mit der Aufforderung an das Array: „Hey, macht euch bereit für mehr Elemente!“ oder „In Ordnung, lasst uns etwas Platz schaffen“. Diese dynamische Anpassung, die während der Ausführung des Programms stattfindet, bietet Vielseitigkeit und Flexibilität, was es zu einem unschätzbaren Werkzeug für Arrays macht, deren anfängliche Größe unbekannt ist.

Syntax:

ArrayResize
(
    array[],          // Reference to the array to be resized
    new_size,         // New size for the array
    reserve_size = 0  // Optional space reserved for future elements
);

Parameter:

• „Array[]“: Dies ist Ihre Spielzeugkiste (Array), deren Größe Sie ändern möchten.
• „new_size“: Dies ist die Anzahl der Spielzeuge (Elemente), die Ihre Box jetzt enthalten soll. Wenn Sie 5 Spielzeuge hätten und Platz für 10 bräuchten, wäre „new_size“ gleich 10.
•  „reserve_size = 0“: Manchmal möchten Sie vielleicht in Zukunft Platz für noch mehr Spielzeug schaffen, ohne die Größe erneut zu ändern. Die „reserve_size“ ist wie eine Aufforderung: „Hey, seid bereit für mehr Spielzeug!“

Beispiel:

void OnStart()
  {

// Dynamic array declaration
   int dynamicArray[];

// Resizing the dynamic array to have 5 elements
   ArrayResize(dynamicArray, 5);

// Assigning values to dynamic array elements
   dynamicArray[0] = 10;
   dynamicArray[1] = 20;
   dynamicArray[2] = 30;
   dynamicArray[3] = 40;
   dynamicArray[4] = 50; 

// Accessing elements in a dynamic array
   Print("Element at index 2: ", dynamicArray[2]); // Output: 30

// Resizing the dynamic array to have 8 elements
   ArrayResize(dynamicArray, 8);

// Assigning values to the additional elements
   dynamicArray[5] = 60;
   dynamicArray[6] = 70;
   dynamicArray[7] = 80;

// Accessing elements after resizing
   Print("Element at index 6: ", dynamicArray[6]); // Output: 70

  }

Erläuterung:

Deklaration eines dynamischen Arrays:

int dynamicArray[];

• Hier wird ein dynamisches Array mit dem Namen „dynamicArray()“ deklariert, ohne dessen Anfangsgröße anzugeben.

Ändern der Größe des dynamischen Arrays auf 5 Elemente:

ArrayResize(dynamicArray, 5);

• Die Funktion „ArrayResize()“ wird verwendet, um die Größe des dynamischen Arrays auf 5 Elemente zu setzen.

Dynamischen Array-Elementen Werte zuweisen:

dynamicArray[0] = 10;
dynamicArray[1] = 20;
dynamicArray[2] = 30;
dynamicArray[3] = 40;
dynamicArray[4] = 50;

• Den einzelnen Elementen des dynamischen Arrays werden Werte zugewiesen.

Zugriff auf Elemente in einem dynamischen Array:

Print("Element at index 2: ", dynamicArray[2]); // Output: 30

• Die Funktion „Print“ wird verwendet, um den Wert bei Index 2 des dynamischen Arrays anzuzeigen. In diesem Fall wird „30“ gedruckt.

Ändern der Größe des dynamischen Arrays auf 8 Elemente:

ArrayResize(dynamicArray, 8);

• Die Größe des dynamischen Arrays wird erneut geändert, sodass es 8 Elemente hat, wobei die Werte der vorherigen Größenänderung beibehalten werden.

Zuweisung von Werten zu zusätzlichen Elementen:

dynamicArray[5] = 60;
dynamicArray[6] = 70;
dynamicArray[7] = 80;

• Nach der Größenänderung werden den neu hinzugefügten Elementen zusätzliche Werte zugewiesen.

Zugriff auf Elemente nach Größenänderung:

Print("Element at index 6: ", dynamicArray[6]); // Output: 70

• Die Funktion Print wird verwendet, um den Wert bei Index 6 des dynamischen Arrays nach der zweiten Größenänderung anzuzeigen. In diesem Fall wird 70 ausgedruckt.

3. ArrayCopy

In MQL5 wird die Funktion „ArrayCopy()“ verwendet, um Elemente zwischen Arrays zu duplizieren. Sie ermöglicht es Ihnen, einen bestimmten, durch einen Bereich definierten Teil eines Arrays selektiv in ein anderes Array zu kopieren. Diese Funktion erleichtert die Verwaltung und Anordnung von Daten innerhalb von Arrays, was das Extrahieren und Verschieben bestimmter Elemente zwischen Arrays erleichtert.

Analogie

Stellen Sie sich vor, Sie haben zwei Listen mit Einträgen und möchten bestimmte Einträge genau von der ersten Liste in die zweite kopieren. Hier ist die Funktion „ArrayCopy()“ von MQL5 nützlich. Sie funktioniert wie ein Kopierassistent, mit dem Sie bestimmte Elemente aus einer Liste auswählen und sie in eine andere Liste kopieren können.

Hier ein konkreteres Beispiel: Stellen Sie sich vor, Sie haben ein Array mit fünf verschiedenen Artikelpreisen und möchten ein zweites Array erstellen, das die Preise von nur drei bestimmten Artikeln enthält. Mit der Funktion „ArrayCopy()“ können Sie genau diese drei Preise extrahieren und in ein neues Array duplizieren, wobei das ursprüngliche Array erhalten bleibt. Dies ist vergleichbar mit einem nützlichen Werkzeug, das das Kopieren und Auswählen von Elementen aus einer Sammlung in eine andere erleichtert und so die Effizienz und Organisation Ihrer Array-Manipulationsaufgaben verbessert.

Syntax:

ArrayCopy( 
          dst_array[],         // The destination array to receive copied elements 
          src_array[],         // The source array from which elements will be copied
          dst_start=0,         // The index in the destination array to start writing from  
          src_start=0,         // The index in the source array from which to start copying 
          count                // The number of elements to copy; default is to copy the entire array
);

Mit diesem leistungsstarken Befehl können Sie Arrays mit Präzision und Kontrolle zusammenführen. Bei diesem Zauberverfahren dient „dst_array“ als Ziel, in das Elemente kopiert werden, und „src_array“ als Quelle, aus der Elemente gezogen werden. Zusätzliche Parameter wie „dst_start“, „src_start“ und „count“ bieten die Flexibilität, den Zusammenführungsvorgang genau anzupassen. Stellen Sie sich einen Befehl vor, der die makellose Fusion von Arrays im fesselnden Bereich der MQL5-Programmierung orchestriert!

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] = 2;
   sourceArray[2] = 3;
   sourceArray[3] = 4;
   sourceArray[4] = 5;

   destinationArray[0] = 10;
   destinationArray[1] = 20;
   destinationArray[2] = 30;
   destinationArray[3] = 40;
   destinationArray[4] = 50;

// Copy elements from sourceArray to destinationArray starting from index 1
   ArrayCopy(destinationArray, sourceArray, 5, 0, WHOLE_ARRAY);

// Print the value of the element at index 7 in destinationArray
   Comment("Value at index 7 in destinationArray: ", destinationArray[7]);

  }

Erläuterung:

Deklaration von Arrays:

int sourceArray[];
int destinationArray[];

• Hier deklarieren Sie zwei dynamische Arrays mit den Namen „sourceArray“ und „destinationArray“.
  

Größenänderung von Arrays:

ArrayResize(sourceArray, 5);
ArrayResize(destinationArray, 5);

• Die Funktion „ArrayResize()“ wird verwendet, um die Größe der dynamischen Arrays festzulegen. In diesem Fall werden beide Arrays auf jeweils 5 Elemente verkleinert.
  

Werte zuweisen:

sourceArray[0] = 1;
sourceArray[1] = 2;
sourceArray[2] = 3;
sourceArray[3] = 4;
sourceArray[4] = 5;

destinationArray[0] = 10;
destinationArray[1] = 20;
destinationArray[2] = 30;
destinationArray[3] = 40;
destinationArray[4] = 50;

• Den einzelnen Elementen des „sourceArray“ und des „destinationArray“ werden Werte zugewiesen.
  

Array kopieren:

ArrayCopy(destinationArray, sourceArray, 5, 0, WHOLE_ARRAY);

• Die Funktion „ArrayCopy()“ wird verwendet, um Elemente von „sourceArray“ nach „destinationArray“ zu kopieren. Er sieht vor, dass 5 Elemente ab Index 0 kopiert werden.
  

Wert drucken:

Comment("Value at index 7 in destinationArray: ", destinationArray[7]);

• Es wird ein Kommentar gedruckt, der den Wert bei Index 7 in „destinationArray“ anzeigt.
  

Der allgemeine Zweck des Codes besteht darin, die Funktion „ArrayCopy()“ zu demonstrieren, indem Elemente von „sourceArray“ nach „destinationArray“ kopiert werden, beginnend mit bestimmten Indizes. Die letzte Zeile gibt den Wert eines Elements in „destinationArray“ aus, um die erfolgreiche Kopie zu bestätigen.

4. ArrayCompare

Die Funktion „ArrayCompare()“ in MQL5 dient als Werkzeug, um zwei Arrays zu vergleichen und ihre Elemente systematisch auszuwerten. Sie beginnt den Vergleich am Anfang (Index 0) der beiden Arrays und prüft, ob die Elemente an den entsprechenden Indizes gleich sind. Wenn alle Elemente übereinstimmen, werden die Arrays als gleich angesehen. Wenn jedoch bei irgendeinem Index eine Diskrepanz auftritt, bewertet die Funktion, welches Feld das numerisch größere Element enthält, und liefert so eine Grundlage für die Bestimmung ihrer Beziehung. Diese Funktion ist besonders nützlich, um die Ähnlichkeit oder Unähnlichkeit zwischen Arrays in Bezug auf ihren Inhalt zu messen.

Analogie

Stellen Sie sich ein Szenario vor, in dem Sie zwei Listen mit Zahlen haben: Liste A und Liste B. „ArrayCompare()“ fungiert als eine Art spezialisierter Ermittler, der diese Listen analysiert und uns über ihre Beziehungen informiert. Der Prüfer beginnt mit den Zahlen am Anfang der beiden Listen und vergleicht sie. Wenn es eine Diskrepanz in den Zahlen feststellt, bestimmt es sofort, welche Liste „größer“ oder „kleiner“ ist. Sie stellt fest, dass die Listen „gleich“ sind, wenn sie beide Listen überprüfen kann und nichts Ungewöhnliches findet.

 

Jetzt hat der Detektiv eine einzigartige Möglichkeit, über seine Ergebnisse zu berichten:

• Wenn die Liste A als kleiner als die Liste B angesehen wird, wird -1 gemeldet.
• Wenn beide Listen als gleichwertig betrachtet werden, ist der Bericht 0.
• Wenn Liste A als größer als Liste B angesehen wird, ist der Bericht 1.
• Wenn es während der Untersuchung zu Unklarheiten oder Problemen kommt, meldet sie -2.

„ArrayCompare()“ hilft uns also, die Beziehung zwischen zwei Listen von Zahlen zu verstehen, so wie ein Detektiv herausfindet, wer in einem Fall wer ist.

Syntax:

int ArrayCompare(const void& array1[], const void& array2[], int start1 = 0, int start2 = 0, int count = WHOLE_ARRAY);

Parameter:

• array1[]: Erstes Array.
•  array2[]: Zweites Array.
• start1: Der Index des Anfangselements im ersten Array, mit dem der Vergleich beginnt. Der Standardstartindex ist 0.
• start2: Der Index des Anfangselements im zweiten Array, ab dem der Vergleich beginnt. Der Standardstartindex ist 0.
• count: Die Anzahl der zu vergleichenden Elemente. Standardmäßig nehmen alle Elemente der beiden Arrays am Vergleich teil (count = WHOLE_ARRAY).

Beispiel:

void OnStart()
  {

// Declare two arrays
   int ListA[] = {1, 2, 3, 4, 5};
   int ListB[] = {1, 2, 3, 4, 6};
// Use ArrayCompare to compare the arrays
   int result = ArrayCompare(ListA, ListB, 0, 0, WHOLE_ARRAY);  
// Print the result
   if(result == -1)
      {
      Print("ListA is less than ListB");
      }
   else if(result == 0)
      {
      Print("ListA is equal to ListB");
      }
   else if(result == 1)
      {
      Print("ListA is greater than ListB");
      }
    else if(result == -2)
      {
       Print("Error: Incompatible arrays or invalid parameters");
      }

  }

Erläuterung:

„int ListA[] = {1, 2, 3, 4, 5};“:

• Das deklariert ein ganzzahliges Array namens „ListA“ und initialisiert es mit den Werten 1, 2, 3, 4 und 5.

„int ListB[] = {1, 2, 3, 4, 6};“:

• Das deklariert ein ganzzahliges Array namens „ListA“ und initialisiert es mit den Werten 1, 2, 3, 4 und 6.

„int result = ArrayCompare(ListA, ListB, 0, 0, WHOLE_ARRAY);“:

• Verwendet die Funktion „ArrayCompare()“, um die Arrays „ListA“ und „ListB“ zu vergleichen. Der Vergleich beginnt bei Index 0 der beiden Felder und vergleicht die gesamten Felder.

Die bedingten Anweisungen („if“, „else if“) prüfen den Wert der Ergebnisvariablen und drucken Meldungen auf der Grundlage des Vergleichsergebnisses:

• Wenn „Ergebnis“ „-1“ ist, bedeutet dies, dass „ListA“ als kleiner als „ListB“ betrachtet wird.
• Wenn „Ergebnis“ „0“ ist, bedeutet dies, dass „ListA“ gleich „ListB“ ist.
• Wenn „Ergebnis“ „1“ ist, bedeutet dies, dass „ListA“ als größer als „ListB“ angesehen wird.
• Wenn „Ergebnis“ „-2“ ist, bedeutet dies einen Fehler aufgrund inkompatibler Arrays oder ungültiger Parameter.

Gegeben die Arrays:

int ListA[] = {1, 2, 3, 4, 5};
int ListB[] = {1, 2, 3, 4, 6};

Das Ergebnis von „ArrayCompare(ListA, ListB, 0, 0, WHOLE_ARRAY)“ wird -1 sein.

Erläuterung:

• Der Vergleich beginnt mit dem ersten Element (Index 0) beider Arrays.
• Die Elemente bei den Indizes 0 bis 3 sind in beiden Arrays gleich.
• Bei Index 4 hat ListA 5, während ListB 6 hat.
• Da 5 < 6 ist, gilt ListA als kleiner als ListB.

Daher ist das Ergebnis -1. Ändern Sie die Werte in ListA und ListB, um zu sehen, wie sich das Ergebnis des Vergleichs ändert!

5. ArrayFree

In MQL5 ist der Aufruf von „ArrayFree()“ gleichbedeutend mit dem Drücken des Reset-Knopfes für Ihr dynamisches Array. Betrachten Sie Ihr Array als einen Behälter für verschiedene Elemente. Es ist vergleichbar mit dem Leeren des Containers und der Vorbereitung für die Aufnahme neuer Elemente, wenn Sie „ArrayFree()“ verwenden. Es ist ein Mittel, um Platz für neue Daten zu schaffen, indem veraltete Informationen beseitigt werden. Anders ausgedrückt: Betrachten Sie es als eine Art Aufräumaktion für das, was als Nächstes kommt. Wenn Sie diese Funktion verwenden, können Sie sicher sein, dass Ihr Array leer und für neue MQL5-Programmiererfahrungen vorbereitet ist.

Analogie

Stellen Sie sich vor, Sie haben eine magische Tasche — Ihr Array. Manchmal möchte man es für andere Dinge verwenden, zum Beispiel zum Sammeln von Spielzeug. Aber bevor Sie neues Spielzeug kaufen, müssen Sie sicherstellen, dass die Tasche leer ist. Das ist es, was „ArrayFree()“ tut — es winkt mit einem Zauberstab und räumt die Tasche auf, damit Sie neue Spielzeuge oder Zahlen hineinlegen können. Es ist, als würde man sagen: „Okay, Tasche, mach dich bereit für noch mehr lustige Sachen!“ So sind Sie bereit für neue Abenteuer mit Ihrer Zaubertasche in der Welt von MQL5.

Syntax:

ArrayFree(array[] // dynamic array to be freed);

Beispiel:

void OnStart()
  {

// Declare a dynamic array
   int dynamicArray[];
// Resize the dynamic array and assign values
   ArrayResize(dynamicArray, 5);
   dynamicArray[0] = 10;
   dynamicArray[1] = 20;
   dynamicArray[2] = 30;
   dynamicArray[3] = 40;
   dynamicArray[4] = 50;
   
// Print elements before freeing the array
   Print("Index 0 before freeing: ", dynamicArray[0]); // Output will be 10
   
// Free the dynamic array using ArrayFree
   ArrayFree(dynamicArray);
   
// Attempting to access elements after freeing (should result in an error)
//   Print("Index 0 after freeing: ", dynamicArray[0]);

// Reassign new values to the array
   ArrayResize(dynamicArray, 3);
   dynamicArray[0] = 100;
   dynamicArray[1] = 200;
   dynamicArray[2] = 300;
   
// Print elements after reassigning values
   Print("Index 0 after reassigning: ", dynamicArray[0]); // Output will be 100

  }

Erläuterung:

Deklarieren eines dynamischen Arrays:

int dynamicArray[];

• Initialisiert ein leeres dynamisches Array.
  

Größe ändern und Werte zuweisen:

ArrayResize(dynamicArray, 5);
dynamicArray[0] = 10;
dynamicArray[1] = 20;
dynamicArray[2] = 30;
dynamicArray[3] = 40;
dynamicArray[4] = 50;

• Ändert die Größe des dynamischen Arrays so, dass es 5 Elemente hat, und weist jedem Element einen Wert zu.
  

Elemente vor dem Freigeben drucken:

Print("Elements before freeing: ", dynamicArray[0]); // Output will be 10

• Druckt den Wert am ersten Index des Arrays, der 10 ist.
  

Geben Sie das dynamische Array frei:

ArrayFree(dynamicArray);

• Gibt den vom dynamischen Array belegten Speicher frei.
  

Versuch, nach dem Freigeben auf Elemente zuzugreifen:

// Print("Elements after freeing: ", dynamicArray[0]);

• Diese Zeile wird auskommentiert, um Laufzeitfehler zu vermeiden, da das Array freigegeben wurde.
  

Zuweisen neuer Werte:

ArrayResize(dynamicArray, 3);
dynamicArray[0] = 100;
dynamicArray[1] = 200;
dynamicArray[2] = 300;

• Ändert die Größe des Arrays, sodass es 3 Elemente hat, und weist ihm neue Werte zu.
  

Elemente nach der Neuzuweisung von Werten drucken:

Print("Elements after reassigning: ", dynamicArray[0]); // Output will be 100

• Druckt den Wert am ersten Index des Arrays nach der Neuzuweisung, also 100.
  

In diesem Beispiel wird nach dem Freigeben des dynamischen Arrays mit „ArrayFree()“ die Größe des Arrays erneut geändert, sodass es 3 Elemente hat, und diesen Elementen werden neue Werte zugewiesen. Dies zeigt, wie Sie ein dynamisches Array wiederverwenden können, nachdem Sie es freigegeben haben.

Es gibt noch mehr Magie zu entdecken, wenn Sie uns durch die Komplexität der MQL5-Array-Funktionen arbeiten. Bleiben Sie dran, um weitere Funktionen zu erkunden, die Ihre Kenntnisse im Umgang mit Code verbessern werden. Der Weg ist noch lange nicht zu Ende, unabhängig davon, wie viel Erfahrung Sie als Entwickler haben. Wenn Sie in den nächsten Abschnitten tiefer in die Wunder eintauchen, warten spannende Entdeckungen auf uns. Lassen Sie uns diese Reise in die Welt des Programmierens gemeinsam fortsetzen, während Sie Ihre Neugierde bewahren!

6. ArraySetAsSeries

In der MQL5-Programmierung ist „ArraySetAsSeries()“ eine Funktion, mit der Sie die Indizierungsrichtung eines Arrays ändern können. Mit dieser Funktion können Sie festlegen, dass der Zugriff auf das Array vom Ende zum Anfang erfolgt, wobei die standardmäßige Vorwärtsrichtung geändert wird. Dies ist besonders nützlich, wenn Sie mit Finanzdaten oder anderen Arrays arbeiten, bei denen der Zugriff auf Elemente in umgekehrter chronologischer Reihenfolge von Vorteil ist.

Anmerkung: Es ist wichtig zu beachten, dass diese Verzauberung speziell auf dynamische Arrays funktioniert, also solche, die ihre Größe während der Laufzeit anständig anpassen können.

Analogie

Stellen Sie sich vor, Sie haben einen Stapel verzauberter Märchenbücher, die fein säuberlich in einem Regal stehen. Jedes Buch ist wie eine besondere Nummer, die darauf wartet, dass Sie ihre spannende Geschichte entdecken. Normalerweise liest man die Geschichten in der Reihenfolge, in der sie im Regal stehen, beginnend mit dem ersten Buch und zum letzten hin.

Stellen Sie sich vor, Sie wollen sich auf die Suche nach der neuesten Geschichte machen, die Sie in Ihre Sammlung aufgenommen haben, ohne alle Bücher aus dem Regal zu nehmen. Hier kommt der Zauber von „ArraySetAsSeries()“ ins Spiel! Wenn Sie diesen Zauberspruch auf Ihr Bücherregal (Array) anwenden, ist das so, als würden Sie sagen: „Wir ordnen die Geschichten so an, dass die neueste, die Sie hinzugefügt haben, auf magische Weise zuerst erscheint.“ Dies ist besonders hilfreich, wenn sich Ihre Geschichten (Zahlen) im Laufe der Zeit ändern, z. B. wenn Sie aufzeichnen, wie viele neue Bücher Sie jeden Tag sammeln. Mit „ArraySetAsSeries()“ können Sie das neueste Märchenbuch zuerst öffnen und dann rückwärts durch Ihre magische Bibliothek reisen, um zu sehen, wie Ihre Sammlung gewachsen ist. Es ist wie ein Rückwärts-Lesezauber für Ihre außergewöhnlichen literarischen Abenteuer!

Syntax:

ArraySetAsSeries(
   array[],    // array to be set as series
   bool   flag // true denotes reverse order of indexing
);

Parameter:

• „array[]“: Dies ist das Array, das Sie mit Zeitreiheneigenschaften versehen wollen. Es ist, als ob man ein magisches Artefakt auswählt, das man mit besonderen Kräften ausstatten möchte.
• “bool flag”: Dies ist ein boolescher Wert. Wenn sie auf „true“ gesetzt ist, aktiviert sie die mystische Umkehrung der Indizierung und verwandelt das Array in ein Zeitreihen-Wunder, bei dem das letzte Element zum ersten wird. Wenn sie auf „false“ gesetzt ist, verhält sich das Array wie ein normales, nicht-magisches Array.

Beispiel:

void OnStart()
  {

// Declare a dynamic array
   int magicalArray[];

// Assign values to the array
   ArrayResize(magicalArray, 5);
   magicalArray[0] = 10;
   magicalArray[1] = 20;
   magicalArray[2] = 30;
   magicalArray[3] = 40;
   magicalArray[4] = 50;

// Print elements before setting as series
   Print("Elements before setting as series:");
   Print("Index 0: ", magicalArray[0]);
   Print("Index 1: ", magicalArray[1]);
   Print("Index 2: ", magicalArray[2]);
   Print("Index 3: ", magicalArray[3]);
   Print("Index 4: ", magicalArray[4]);

// Set the array as a series
   ArraySetAsSeries(magicalArray, true);

// Print elements after setting as series
   Print("Elements after setting as series:");
   Print("Index 0: ", magicalArray[0]);
   Print("Index 1: ", magicalArray[1]);
   Print("Index 2: ", magicalArray[2]);
   Print("Index 3: ", magicalArray[3]);
   Print("Index 4: ", magicalArray[4]);

  }

Erläuterung:

Deklaration eines dynamischen Arrays:

double magicalArray[];

• Deklariert ein dynamisches Array mit dem Namen „magicalArray“ ohne Angabe seiner Größe.
  

Zuweisen von Werten dem Array:

ArrayResize(magicalArray, 5);
magicalArray[0] = 10;
magicalArray[1] = 20;
magicalArray[2] = 30;
magicalArray[3] = 40;
magicalArray[4] = 50;

• Wir ändern die Größe des Arrays, sodass es 5 Elemente hat.
  
• Anschließend weisen Sie jedem Element des Arrays bestimmte Werte zu.
  

Elemente vor der Einstellung als Serie drucken:

Print("Elements before setting as series:");
Print("Index 0: ", magicalArray[0]); // output will be 10
Print("Index 1: ", magicalArray[1]); // output will be 20
Print("Index 2: ", magicalArray[2]); // output will be 30
Print("Index 3: ", magicalArray[3]); // output will be 40
Print("Index 4: ", magicalArray[4]); // output will be 50

• In diesem Abschnitt werden die Werte der einzelnen Elemente des Arrays ausgedruckt, bevor sie als Reihe festgelegt werden.
  

Einrichten des Arrays als Serie:

ArraySetAsSeries(magicalArray, true);

• Wir verwenden „ArraySetAsSeries()“, um das Array als Serie einzurichten. Der zweite Parameter „true“ gibt die umgekehrte Reihenfolge der Indizierung an.
  

Elemente nach Einstellung als Serie drucken:

Print("Elements after setting as series:");
Print("Index 0: ", magicalArray[0]); // output will be 50
Print("Index 1: ", magicalArray[1]); // output will be 40
Print("Index 2: ", magicalArray[2]); // output will be 30
Print("Index 3: ", magicalArray[3]); // output will be 20
Print("Index 4: ", magicalArray[4]); // output will be 10

• Zum Schluss werden die Werte der einzelnen Elemente ausgedruckt, nachdem das Array als Serie festgelegt wurde. Die Reihenfolge des Drucks spiegelt die umgekehrte Indexierung aufgrund der Einstellung als Serie wider.
  

Zusammenfassend demonstriert der Code, wie man einem dynamischen Array Werte zuweist, seine Elemente vor und nach dem Einstellen als Serie ausgibt und die Änderung der Indizierungsreihenfolge beobachtet.

Auf der bezaubernden Reise der MQL5-Programmierung haben Sie die magische Funktion „ArraySetAsSeries()“ erkundet. Es ist, als ob man mit einem Zauberstab die Reihenfolge der Zeitreisefähigkeiten eines Arrays umkehren könnte! Denken Sie daran, dass Übung den Meister macht, wenn Sie dieses Kapitel abschließen. Probieren Sie neue Dinge aus, lesen Sie langsam, und stellen Sie ruhig Fragen. Die Community kann Ihnen bei Ihren magischen Programmierabenteuern helfen. Auf mehr Coding, Prost!

7. ArrayGetAsSeries

Die Funktion „ArrayGetAsSeries()“ in MQL5 wird verwendet, um festzustellen, ob ein Array das AS_SERIES-Flag gesetzt hat. Dieses Flag beeinflusst die Reihenfolge, in der auf Array-Elemente zugegriffen wird. Gibt die Funktion den Wert true zurück, bedeutet dies, dass auf die Elemente in umgekehrter Reihenfolge zugegriffen wird; andernfalls, wenn sie false zurückgibt, behält das Array seine Standardreihenfolge bei. Diese Funktion ist praktisch, wenn es um Arrays geht, bei denen die Reihenfolge des Datenzugriffs entscheidend ist. Sie bietet eine Möglichkeit, das Datenzugriffsmuster auf der Grundlage der Konfiguration des Arrays zu überprüfen und anzupassen.

Analogie

Stellen Sie sich vor, Sie haben eine magische Liste von Zahlen, und manchmal spielt diese Liste gerne ein besonderes Spiel namens „Zeitreise“. Wenn Sie dieses magische Werkzeug „ArrayGetAsSeries()“ fragen, sagt es Ihnen, ob Ihre Liste das Spiel spielt oder nicht. Steht dort „true“, bedeutet das, dass die Liste abgespielt wird, und Sie lesen die Zahlen rückwärts, als ob Sie rückwärts zählen würden. Steht dort „falsch“, ist die Liste ganz normal, und Sie lesen die Zahlen vom Anfang bis zum Ende, wie beim Aufwärtszählen. Es hilft Ihnen also, die Regeln Ihrer magischen Liste zu verstehen!

Syntax:

bool ArrayGetAsSeries(
array[]    // // The array that is being examined for its time series configuration.
);

Beispiel:

void OnStart()
  {

// Declare two dynamic arrays
   int timeSeriesArray[];
   int regularArray[];
// Resize the arrays to have 5 elements
   ArrayResize(timeSeriesArray, 5);
   ArrayResize(regularArray, 5);
// Assign values to the arrays
   timeSeriesArray[0] = 1;
   timeSeriesArray[1] = 2;
   timeSeriesArray[2] = 3;
   timeSeriesArray[3] = 4;
   timeSeriesArray[4] = 5;

   regularArray[0] = 5;
   regularArray[1] = 4;
   regularArray[2] = 3;
   regularArray[3] = 2;
   regularArray[4] = 1;
// Set the time series flag for the first array
   ArraySetAsSeries(timeSeriesArray, true);
// Check if the dynamic arrays follow the time series convention using if statements
   if(ArrayGetAsSeries(timeSeriesArray))
     {
      Print("timeSeriesArray is a time series. Elements are accessed from end to beginning.");
     }
   else
     {
      Print("timeSeriesArray maintains its original order. Elements are accessed from beginning to end.");
     }

   if(ArrayGetAsSeries(regularArray))
     {
      Print("regularArray is a time series. Elements are accessed from end to beginning.");
     }
   else
     {
      Print("regularArray maintains its original order. Elements are accessed from beginning to end.");
     }

  }

Erläuterung:

// Declare two dynamic arrays
int timeSeriesArray[];
int regularArray[];

• Diese Zeilen deklarieren zwei dynamische Arrays mit den Namen „timeSeriesArray“ und „regularArray“. Dynamische Arrays in MQL5 können ihre Größe während der Laufzeit ändern.
  

// Resize the arrays to have 5 elements
ArrayResize(timeSeriesArray, 5);
ArrayResize(regularArray, 5);

• In diesen Zeilen wird die Funktion „ArrayResize()“ verwendet, um die Größe der beiden Arrays auf 5 Elemente zu setzen. Mit diesem Schritt wird sichergestellt, dass die Arrays genügend Platz zum Speichern von Elementen haben.
  

// Assign values to the arrays
timeSeriesArray[0] = 1;
timeSeriesArray[1] = 2;
timeSeriesArray[2] = 3;
timeSeriesArray[3] = 4;
timeSeriesArray[4] = 5;

regularArray[0] = 5;
regularArray[1] = 4;
regularArray[2] = 3;
regularArray[3] = 2;
regularArray[4] = 1;

• Diese Zeilen weisen den Elementen der beiden Arrays bestimmte Werte zu. „timeSeriesArray“ werden Werte in aufsteigender Reihenfolge zugewiesen, während „regularArray“ Werte in absteigender Reihenfolge zugewiesen werden.
  

// Set the time series flag for the first array
ArraySetAsSeries(timeSeriesArray, true);

• In dieser Zeile wird die Funktion „ArraySetAsSeries()“ verwendet, um das Zeitreihenflag für „timeSeriesArray“ auf „true“ zu setzen. Dies bedeutet, dass auf die Elemente in „timeSeriesArray“ vom Ende bis zum Anfang zugegriffen wird.
  

// Check if the dynamic arrays follow the time series convention using if statements
    if(ArrayGetAsSeries(timeSeriesArray))
    {
        Print("timeSeriesArray is a time series. Elements are accessed from end to beginning.");
    }
    else
    {
        Print("timeSeriesArray maintains its original order. Elements are accessed from beginning to end.");
    }

    if(ArrayGetAsSeries(regularArray))
    {
        Print("regularArray is a time series. Elements are accessed from end to beginning.");
    }
    else
    {
        Print("regularArray maintains its original order. Elements are accessed from beginning to end.");
    }

• Der mitgelieferte Codeschnipsel prüft, ob die dynamischen Arrays „timeSeriesArray“ und „regularArray“ die Zeitreihenkonvention mit Hilfe von bedingten Anweisungen einhalten. Es verwendet die Funktion „ArrayGetAsSeries()“, um festzustellen, ob das Zeitreihenflag für jedes Array gesetzt ist. Die erste „if“-Anweisung prüft „timeSeriesArray“, und wenn es als Zeitreihe identifiziert wird, wird eine entsprechende Meldung ausgegeben, die angibt, dass auf die Elemente von Ende zu Anfang zugegriffen wird. Wenn nicht, gibt der „else“-Block eine Meldung aus, die besagt, dass „timeSeriesArray“ seine ursprüngliche Reihenfolge beibehält und auf die Elemente von Anfang bis Ende zugegriffen wird. Der Vorgang wird für „regularArray“ wiederholt. Diese bedingte Prüfung ist für das Verständnis der Indizierung von Elementen in diesen dynamischen Arrays von entscheidender Bedeutung und liefert wertvolle Erkenntnisse über die Richtung des Array-Zugriffs.
  

Das Verständnis der Feinheiten von „ArrayGetAsSeries()“ ist eine wertvolle Fähigkeit in MQL5. Ganz gleich, ob Sie durch Zeitreihendaten navigieren oder mit Arrays in ihrer ursprünglichen Reihenfolge arbeiten, diese Funktionen unterstützen Sie auf Ihrem Weg zum algorithmischen Handel. Als Anfänger sollten Sie Fragen stellen, und damit können Sie die Gemeinschaft gemeinsam aufbauen. Viel Spaß beim Codieren!

8. ArrayIsSeries

Um festzustellen, ob ein Array in MQL5 eine Zeitreihe darstellt, ist die Funktion „ArrayIsSeries()“ unerlässlich. Ein Array, das zeitbezogene Daten enthält, wird in der Finanzprogrammierung als Zeitreihe bezeichnet und häufig verwendet, um Preiswerte wie Eröffnungs-, Höchst-, Tiefst- und Schlusskurse zu speichern. Wenn eine Zeitreihe erkannt wird, analysiert die Funktion das angegebene Array und gibt „true“ zurück; andernfalls gibt sie „false“ zurück. Diese Bestimmung ist wichtig, wenn man mit Finanzdaten auf einem Chart arbeitet, bei dem das Verständnis der zeitlichen Natur der Daten entscheidend ist.

Bei der Erstellung von nutzerdefinierten Indikatoren in MQL5, insbesondere im Kontext der technischen Analyse, ist es wichtig, zwischen regulären Arrays und Zeitreihen-Arrays zu unterscheiden. Die Funktion „ArrayIsSeries()“ vereinfacht diesen Prozess und ermöglicht es Entwicklern, ihren Code darauf abzustimmen, ob das Array zeitabhängige Informationen enthält. Diese Funktion trägt zur Effizienz und Genauigkeit von algorithmischen Handelsstrategien, technischen Analysetools und anderen Finanzanwendungen bei, die mit der Sprache MQL5 entwickelt wurden.

Unterschied zwischen ArrayGetAsSeries und ArrayIsSeries

Sowohl „ArrayGetAsSeries()“ als auch „ArrayIsSeries()“ sind Funktionen, die sich auf das Verhalten von Arrays beziehen, aber sie dienen unterschiedlichen Zwecken. “ArrayGetAsSeries()“ wird verwendet, um zu prüfen, ob die Indizierung eines Arrays so eingestellt ist, dass die Elemente von hinten nach vorne abgerufen werden, was gemeinhin als umgekehrte Reihenfolge bezeichnet wird. Diese Funktion ist bei der Manipulation von Arrays nützlich, da sie es Entwicklern ermöglicht, festzustellen, ob der Zugriff auf Daten in chronologischer oder umgekehrter Reihenfolge erfolgt. Sie gibt „true“ zurück, wenn das Array als Serie eingestellt ist (Zugriff in umgekehrter Reihenfolge) und „false“ andernfalls.

ArrayIsSeries()“ hingegen konzentriert sich darauf, festzustellen, ob ein Array eine Zeitreihe ist. Zeitreihen-Arrays sind in der Finanzprogrammierung weit verbreitet und stellen Daten wie Eröffnungs-, Höchst-, Tiefst- und Schlusskurse im Zeitverlauf dar. Im Gegensatz zu „ArrayGetAsSeries()“ kümmert sich „ArrayIsSeries()“ nicht um die Richtung der Array-Indexierung. Stattdessen wird geprüft, ob das Array zeitbezogene Informationen enthält. Wenn es sich bei dem Array um eine Zeitreihe handelt, wird „true“ zurückgegeben; andernfalls wird „false“ zurückgegeben. Diese Funktionen ergänzen sich gegenseitig und bieten ein umfassendes Toolkit für den Umgang mit Array-Verhalten, das Flexibilität beim Umgang mit verschiedenen Arten von Finanzdaten in algorithmischen Handelssystemen und technischen Analysetools bietet.

Analogie

Stellen Sie sich vor, Sie hätten jeden Tag eine Liste mit Dingen, wie z. B. den Preisen Ihrer Lieblingsspielzeuge. Wenn Sie nun wissen wollen, ob diese Liste etwas Besonderes ist und mit der Zeit zusammenhängt, genau wie eine Geschichte, können Sie den Zauberspruch „ArrayIsSeries()“ verwenden. Dieser Zauberspruch prüft, ob Ihre Liste einen zeitreisenden Touch hat, was sie zu einer „Zeitserie“ macht. Es ist egal, ob die Liste rückwärts oder vorwärts gelesen wird; es interessiert sich mehr dafür, ob es sich um ein zeitreisendes Abenteuer handelt.

Wenn der Spruch also „true“ ist, bedeutet das, dass Ihre Liste wie eine Zeitreisegeschichte ist, die vielleicht die Preise von Spielzeug über Tage hinweg zeigt. Steht dort aber „false“, ist Ihre Liste vielleicht nur eine gewöhnliche Ansammlung von Zahlen ohne zeitbezogene Magie. Das ist wie die Frage: „Ist diese Liste eine besondere Zeitreisegeschichte?“ Und der Zauberspruch gibt uns eine einfache Antwort — ja oder nein!

Syntax:

bool ArrayIsSeries(
array[] //the array you want to check if it's a timeseries.
)

Beispiel:

void OnStart()
  {

// Declare an array
   double priceSeries[];
// Resize the array and assign values (considering it as a time series)
   ArrayResize(priceSeries, 5);
   priceSeries[0] = 1.1;
   priceSeries[1] = 1.2;
   priceSeries[2] = 1.3;
   priceSeries[3] = 1.4;
   priceSeries[4] = 1.5;
// Check if the array is a time series
   bool isSeries = ArrayIsSeries(priceSeries);
// Print the result
   if(isSeries)
     {
      Print("This array is a time series!");
     }
   else
     {
      Print("This array is not a time series.");
     }

  }

Erläuterung:

// Declare an array
double priceSeries[];

• In dieser Zeile wird ein leeres dynamisches Array mit dem Namen „priceSeries“ deklariert, um reelle Zahlen zu speichern.
  

// Resize the array and assign values (considering it as a time series)
ArrayResize(priceSeries, 5);
priceSeries[0] = 1.1;
priceSeries[1] = 1.2;
priceSeries[2] = 1.3;
priceSeries[3] = 1.4;
priceSeries[4] = 1.5;

• Hier wird die Größe des Arrays so geändert, dass es 5 Elemente hat, und jedem Element werden bestimmte Werte zugewiesen. Diese Werte stellen eine hypothetische Zeitreihe dar.
  

// Check if the array is a time series
bool isSeries = ArrayIsSeries(priceSeries);

• In dieser Zeile wird die Funktion „ArrayIsSeries()“ verwendet, um zu prüfen, ob das Array „priceSeries“ als Zeitreihe gilt. Das Ergebnis („true“ oder „false“) wird in der booleschen Variablen „isSeries“ gespeichert.
  

// Print the result
if (isSeries) {
    Print("This array is a time series!");
} else {
    Print("This array is not a time series.");
}

• Schließlich gibt der Code eine Meldung aus, die angibt, ob das Array auf der Grundlage des mit „ArrayIsSeries()“ erhaltenen Ergebnisses als Zeitreihe betrachtet wird. Handelt es sich um eine Zeitreihe, wird eine Meldung gedruckt; andernfalls wird eine weitere Meldung gedruckt.
  

Die Ausgabe lautet in diesem Fall: „Dieses Array ist keine Zeitreihe“. Warum? Da Ihr Array keine Zeitreihe darstellt, selbst wenn Sie ihm Werte zuweisen, ist mir klar, dass es auf den ersten Blick, insbesondere für Neulinge, etwas verwirrend sein könnte. Aber für den Moment werden Sie es einfach halten. Wir freuen uns über Anfragen, wenn Sie mehr herausfinden und gemeinsam lernen.

9. ArrayInitialize

„ArrayInitialize()“ ist eine Funktion in MQL5, die die Anfangswerte aller Elemente in einem numerischen Array auf einen bestimmten voreingestellten Wert setzt. Anstatt jedem Element einzeln den gleichen Wert zuzuweisen, rationalisiert „ArrayInitialize()“ den Prozess, indem der gewählte Wert auf alle Elemente auf einmal angewendet wird. Diese Funktion ist nützlich, um ein Array mit einem konsistenten Startpunkt vorzubereiten, insbesondere wenn es sich um numerische Daten handelt, für die eine einheitliche Initialisierung erforderlich ist. Beachten Sie, dass dies nur die Anfangswerte setzt und keine Auswirkungen auf Reserveelemente oder zukünftige Erweiterungen hat, die mit „ArrayResize()“ vorgenommen wurden.

Analogie

Stellen Sie sich vor, Sie haben eine Reihe von magischen Containern, die Arrays genannt werden, und jeder Container hat einige spezielle Bereiche, in denen Werte gespeichert werden können. Wenn Sie nun mit einem bestimmten Wert in all diesen Bereichen beginnen wollen, verwenden Sie einen speziellen Befehl namens „ArrayInitialize()“. Mit diesem Befehl können Sie auf magische Weise den gewünschten Anfangswert für alle Felder auf einmal einstellen, sodass Sie sich die Mühe ersparen, dies für jedes Feld einzeln zu tun.

Aber jetzt kommt der interessante Teil: Wenn Sie später beschließen, diese Container zu vergrößern und ihnen mit einem anderen magischen Befehl (ArrayResize) mehr Leerzeichen hinzuzufügen, werden die neuen Leerzeichen zwar da sein, aber sie werden nicht die gleichen magischen Werte haben wie die ursprünglichen. Sie müssen die Werte für jeden einzelnen Eintrag separat auswählen, da sie sich leicht unterscheiden. Es ist ähnlich wie bei der Erweiterung der Innenräume Ihres Schlosses — Sie richten die neuen Räume nicht immer mit denselben Möbeln ein wie die alten.

Syntax:

int ArrayInitialize(
   array[],   // initialized array
   value       // value that will be set
);

Beispiel:

void OnStart()
  {

// Declare a dynamic array
   int myArray[];

// Resize the array to have an initial size (let's use 3 elements)
   ArrayResize(myArray, 3);

// Assign values to all elements before initialization
   myArray[0] = 10;
   myArray[1] = 20;
   myArray[2] = 30;

// Assign values to all elements before initialization
   myArray[0] = 10;
   myArray[1] = 20;
   myArray[2] = 30;

// Initialize the array with a value (let's use 0.0)
   ArrayInitialize(myArray, 0);

// Print the values of all elements after initialization
   Print("Values after initialization:");
   Print("myArray[0] = ", myArray[0]); // outpot wil be 0
   Print("myArray[1] = ", myArray[1]); // outpot wil be 0
   Print("myArray[2] = ", myArray[2]); // outpot wil be 0
// Resize the array to have 5 elements
   ArrayResize(myArray, 5);

// Assign values to the additional elements after resizing
   myArray[3] = 40;
   myArray[4] = 50;

// Print the values of all elements after resizing
   Print("Values after resizing:");
   Print("myArray[3] = ", myArray[3]); // outpot wil be 40
   Print("myArray[4] = ", myArray[4]); // outpot wil be 50


  }

Erläuterung:

// Declare a dynamic array
   int myArray[];

• Hier deklarieren Sie ein dynamisches Integer-Array mit dem Namen „myArray“. Es gibt keine vordefinierte Größe.
  

// Resize the array to have an initial size (let's use 3 elements)
   ArrayResize(myArray, 3);

• Wir passen die Größe von „myArray“ an, sodass die anfängliche Größe 3 Elemente beträgt. Das bedeutet, dass Sie Speicher für drei ganze Zahlen in dem Array zuweisen.
  

// Assign values to all elements before initialization
   myArray[0] = 10;
   myArray[1] = 20;
   myArray[2] = 30;

• Bevor Sie das Array initialisieren, weisen Sie seinen Elementen manuell Werte zu. In diesem Fall setzen Sie „myArray[0]“ auf 10, „myArray[1]“ auf 20 und „myArray[2]“ auf 30.
  

// Initialize the array with a value (let's use 0.0)
   ArrayInitialize(myArray, 0);

• Nun verwenden Sie die Funktion „ArrayInitialize()“, um alle Elemente von „myArray“ auf den angegebenen Wert zu setzen, der in diesem Fall 0 ist.
  

// Print the values of all elements after initialization
Print("Values after initialization:");
Print("myArray[0] = ", myArray[0]); // Output will be 0
Print("myArray[1] = ", myArray[1]); // Output will be 0
Print("myArray[2] = ", myArray[2]); // Output will be 0

• Nach der Initialisierung geben Sie die Werte aller Elemente in „myArray“ aus. Wie erwartet, wurden alle Elemente auf 0 gesetzt.
  

// Resize the array to have 5 elements
ArrayResize(myArray, 5);

• Als Nächstes wird die Größe von „myArray“ so angepasst, dass es insgesamt 5 Elemente hat. Das bedeutet, dass das Feld nun zwei weitere Elemente aufnehmen kann.
  

// Assign values to the additional elements after resizing
myArray[3] = 40;
myArray[4] = 50;

• Nach der Größenänderung weisen Sie den zusätzlichen Elementen („myArray[3]“ und „myArray[4]“) Werte zu.
  

// Print the values of all elements after resizing
Print("Values after resizing:");
Print("myArray[3] = ", myArray[3]); // Output will be 40
Print("myArray[4] = ", myArray[4]); // Output will be 50

• Schließlich drucken Sie die Werte aller Elemente in „myArray“ nach der Größenänderung, einschließlich der neu hinzugefügten Elemente.
  

Ein leistungsfähiges Werkzeug, mit dem Programmierer den Wert jedes Elements in einem Array auf einen bestimmten Wert setzen können, ist die Funktion „ArrayInitialize()“ in MQL5. Dies gewährleistet einen konsistenten Startpunkt für jedes Array-Element und bietet Klarheit und Kontrolle über den Anfangszustand des Arrays. Denken Sie daran, dass die Funktion jedes Element mit der gleichen angegebenen Zahl initialisiert. Dies mag einfach erscheinen, ist aber ein wichtiger Schritt bei der Einrichtung von Arrays für verschiedene Arten von Anwendungen. In späteren Artikeln werden Sie tiefer in den Bereich des algorithmischen Handels eintauchen, was die Bedeutung von „ArrayInitialize()“ hervorheben wird. Bleiben Sie konzentriert und haben Sie Spaß am Coding!

10. ArrayFill

„ArrayFill()“ ist eine Funktion in MQL5, die eine wichtige Rolle bei der Vereinfachung von Array-Manipulationsaufgaben spielt. Diese Funktion ermöglicht es Entwicklern, einen Bereich von Array-Elementen effizient mit einem bestimmten Wert zu füllen, wodurch die Notwendigkeit einer manuellen Iteration und Zuweisung entfällt. Anstatt mehrere Codezeilen zu schreiben, um jedes Element einzeln zu setzen, bietet „ArrayFill()“ eine prägnante und effektive Lösung. Diese Fähigkeit verbessert die Lesbarkeit des Codes und verringert die Fehlerwahrscheinlichkeit, insbesondere bei großen Arrays oder sich wiederholenden Zuweisungen. Die Fähigkeit der Funktion, Array-Elemente schnell mit einem gemeinsamen Wert aufzufüllen, rationalisiert den Kodierungsprozess und macht sie zu einem wertvollen Werkzeug für die Handhabung verschiedener Szenarien, in denen eine Masseninitialisierung erforderlich ist.

Analogie

Nehmen Sie an, Sie haben eine Kiste mit mehreren Fächern und möchten einige dieser Fächer für dasselbe Spielzeug verwenden, ohne jedes einzelne Fach durchgehen zu müssen. Wie ein Zauberspruch erlaubt „ArrayFill()“ die Auswahl eines Spielzeugs und die Anweisung „Fülle diese Felder mit diesem Spielzeug“. So können Sie alle Spielzeuge auf einmal platzieren, anstatt sie einzeln zu platzieren! Das ist so, als würde man jemandem, der einen Haufen Spielzeugautos hat, sagen: „Füllen Sie die ersten fünf Fächer mit roten Autos und die nächsten fünf mit blauen“. Dieser zeitsparende Zaubertrick hilft Ihnen, Ordnung in Ihrer Spielzeugkiste zu halten!

Syntax:

ArrayFill(
    array[], // array to be filled
    start,   // Starting slot (index) for filling
    count,   // Number of slots to fill
    value    // The value to fill the slots with
);

Parameter

• „array[]“: Dies ist Ihre Reihe von Regalen.
• „start“: Dies ist wie die Angabe des ersten Regals, in das Sie Artikel stellen möchten. Sie geben den Index oder die Position an.
•  „count“: Das ist so ähnlich, als würde man sagen: „Ich möchte diesen Artikel in die nächsten X Regale stellen“. Sie bestimmen die Anzahl der zu füllenden Fächer.
• „value“: Dies ist der Artikel, den Sie in die Regale stellen wollen. Es kann ein beliebiger Gegenstand sein - eine Zahl, eine Farbe oder alles, was in die Regale passt.

Beispiel:

void OnStart()
  {

// Declare an array of shelves
   int roomShelves[];

// Set the size of the array (number of shelves)
   ArrayResize(roomShelves, 10);

// Fill the first 5 shelves with books (value 42)
   ArrayFill(roomShelves, 0, 5, 42);

// Fill the next 5 shelves with toys (value 99)
   ArrayFill(roomShelves, 5, 5, 99);

// Display the contents of the shelves after filling
   Print("Contents of the shelves after filling:");
   Print("Shelf 0: ", roomShelves[0]); // output will be 42
   Print("Shelf 1: ", roomShelves[1]); // output will be 42
   Print("Shelf 2: ", roomShelves[2]); // output will be 42
   Print("Shelf 3: ", roomShelves[3]); // output will be 42
   Print("Shelf 4: ", roomShelves[4]); // output will be 42
   Print("Shelf 5: ", roomShelves[5]); // output will be 99
   Print("Shelf 6: ", roomShelves[6]); // output will be 99
   Print("Shelf 7: ", roomShelves[7]); // output will be 99
   Print("Shelf 8: ", roomShelves[8]); // output will be 99
   Print("Shelf 9: ", roomShelves[9]); // output will be 99

  }

Erläuterung:

„int roomShelves[];“:

• Deklariert ein Integer-Array mit dem Namen „roomShelves“, um die Regale in einem Raum darzustellen.

“ArrayResize(roomShelves, 10);“:

• Ändert die Größe des Arrays „roomShelves“ so, dass es 10 Elemente enthält, die 10 Regale im Raum darstellen.

„ArrayFill(roomShelves, 0, 5, 42);“:

• Füllt die ersten 5 Fächer (Indizes 0 bis 4) mit dem Wert 42, der die Bücher in diesen Fächern repräsentiert.

„ArrayFill(roomShelves, 5, 5, 99);“:

• Füllt die nächsten 5 Regale (Indizes 5 bis 9) mit dem Wert 99, der für die Spielzeuge in diesen Regalen steht.

„Print("Contents of the shelves after filling:");“:

• Gibt eine Meldung aus, die besagt, dass die folgenden Zeilen den Inhalt der Regale anzeigen werden.

„Print("Shelf 0: ", roomShelves[0]);” to “Print("Shelf 9: ", roomShelves[9]);“:

• Druckt den Inhalt jedes Regals, wobei der Index des Regals und der entsprechende Wert angezeigt werden

Dieser MQL5-Code zeigt, wie man ein dynamisches Array namens „roomShelves“ mit der Funktion „ArrayFill()“ füllt. Ursprünglich wurde die Anordnung auf zehn Fächer verkleinert. Im nächsten Schritt wird „ArrayFill()“ verwendet, um die ersten fünf Fächer mit 42 und die nächsten fünf Fächer mit 99 zu füllen. Die Werte, die den einzelnen Elementen des Arrays nach dem Füllvorgang zugewiesen werden, werden schließlich beim Ausdrucken des Inhalts der einzelnen Fächer sichtbar. Der Code zeigt, wie „ArrayFill()“ eine flexible Methode bietet, um vordefinierte Werte innerhalb einer Array-Struktur zu setzen, indem bestimmte Segmente eines dynamischen Arrays effektiv mit vordefinierten Werten initialisiert werden.

Anmerkung: „ArrayFill()“ und „ArrayInitialize()“ sind beides Array-Manipulationsfunktionen in MQL5, aber sie dienen unterschiedlichen Zwecken. „ArrayFill()“ dient dazu, einen bestimmten Bereich von Elementen innerhalb eines Arrays mit einem bestimmten Wert zu füllen. Sie ermöglicht eine effiziente Massenzuweisung an eine Teilmenge des Arrays und ist daher nützlich, um Teile des Arrays selektiv zu ändern oder zu initialisieren. Im Gegensatz dazu ist „ArrayInitialize()“ eine allgemeinere Funktion, die einheitlich den Wert aller Elemente im gesamten Array setzt. Sie gewährleistet einen konsistenten Ausgangszustand für das gesamte Array und bietet eine schnelle Möglichkeit, alle Elemente mit demselben Wert zu initialisieren. Während „ArrayFill()“ also auf gezielte Zuweisungen spezialisiert ist, ist „ArrayInitialize()“ ein breiteres Werkzeug für eine einheitliche Initialisierung des gesamten Arrays.

11. ArrayIsDynamic

Um festzustellen, ob ein Array dynamisch oder statisch ist, ist ein nützliches Werkzeug in MQL5 die Funktion „ArrayIsDynamic()“. Die Größe eines statischen Arrays ist zur Kompilierzeit festgelegt, während die Größe eines dynamischen Arrays zur Laufzeit geändert werden kann. „ArrayIsDynamic()“ stellt fest, ob ein Array dynamisch oder statisch ist und gibt je nach Art des Arrays eine einfache „true“ oder „false“ Antwort zurück. Mit Hilfe dieser Daten kann das Programm sein Verhalten an die Flexibilität des Arrays anpassen, indem es festlegt, ob seine Größe während der Programmausführung geändert werden kann.

Analogie

Ein Array ist so etwas wie eine magische Kiste in der Welt der Programmierung, die mehrere Objekte aufnehmen kann. Einige Kartons verfügen jetzt über einen besonderen Zauber, der es ihnen ermöglicht, ihre Größe zu verändern, damit mehr Gegenstände hineinpassen oder sie bei Bedarf weniger Platz einnehmen. Diese werden als dynamische Boxen bezeichnet. Umgekehrt gibt es Boxen, deren Größe festgelegt ist und die sich unter keinen Umständen verändern. Diese werden als statische Boxen bezeichnet.

Um nun festzustellen, ob ein Feld dynamisch oder statisch ist, können Sie die assistentenähnliche Funktion „ArrayIsDynamic()“ verwenden. Die Ergebnisse dieses Zaubers zeigen an, ob der Kasten statisch ist — seine Größe bleibt konstant — oder dynamisch — er kann seine Größe ändern. Programmierer müssen diese Dinge wissen, weil sie sinnvoll sind, wenn sie entscheiden, wie sie die Box in ihrem magischen Code manipulieren wollen. Wenn es sich um ein statisches System handelt, müssen sie darauf achten, dass die festgelegte Größe nicht überschritten wird; wenn es sich um ein dynamisches System handelt, können sie es nach Bedarf vergrößern oder verkleinern.

Syntax:

bool ArrayIsDynamic(array[]   // array to be checked);

Beispiel:

void OnStart()
  {

// Declare a static array
   int staticArray[5];

// Declare a dynamic array
   int dynamicArray[];

// Check if the static array is dynamic
   bool isStaticArrayDynamic = ArrayIsDynamic(staticArray);

   if(isStaticArrayDynamic)
     {
      Print("The staticArray is dynamic.");  // This message won't be printed.
     }
   else
     {
      Print("The staticArray is static, meaning its size is fixed.");
     }

// Check if the dynamic array is dynamic
   bool isDynamicArrayDynamic = ArrayIsDynamic(dynamicArray);

   if(isDynamicArrayDynamic)
     {
      Print("The dynamicArray is dynamic, meaning its size can be changed.");
     }
   else
     {
      Print("The dynamicArray is static.");  // This message won't be printed.
     }
     
  }

Erläuterung:

„int staticArray[5];“:

• In dieser Zeile wird ein Array namens „staticArray“ mit einer festen Größe von 5 Elementen deklariert.

„int dynamicArray[];“:

• In dieser Zeile wird ein dynamisches Array mit dem Namen „dynamicArray“ deklariert, ohne dass eine feste Größe angegeben wird.

„bool isStaticArrayDynamic = ArrayIsDynamic(staticArray);“:

• Diese Zeile verwendet die Funktion „ArrayIsDynamic()“, um zu prüfen, ob „staticArray“ dynamisch ist, und weist das Ergebnis „isStaticArrayDynamic“ zu.

„bool isStaticArrayDynamic = ArrayIsDynamic(staticArray);“:

• Diese Zeile verwendet die Funktion „ArrayIsDynamic()“, um zu prüfen, ob „staticArray“ dynamisch ist, und weist das Ergebnis „isStaticArrayDynamic“ zu.

Druckt das Ergebnis für das statische Array:

• Der anschließende „if-else“-Block gibt eine Meldung aus, die angibt, ob „staticArray“ dynamisch oder statisch ist, und zwar auf der Grundlage des im vorherigen Schritt erzielten Ergebnisses.

„bool isDynamicArrayDynamic = ArrayIsDynamic(dynamicArray);“:

• In dieser Zeile wird mit der Funktion „ArrayIsDynamic()“ geprüft, ob „dynamicArray“ dynamisch ist, und das Ergebnis wird „isDynamicArrayDynamic“ zugewiesen.

Ausdruck des Ergebnisses für das dynamische Array:

• Der anschließende „if-else“-Block gibt eine Meldung aus, die angibt, ob „dynamicArray“ dynamisch oder statisch ist, und zwar auf der Grundlage des im vorherigen Schritt erzielten Ergebnisses.

Der Code demonstriert die Verwendung von „ArrayIsDynamic()“, um festzustellen, ob ein Array dynamisch oder statisch ist.

12. ArrayMaximum

Die Funktion „ArrayMaximum()“ in MQL5 ist ein leistungsfähiges Werkzeug, um den Index des maximalen Elements innerhalb eines numerischen Arrays zu ermitteln. Diese Funktion erweist sich als besonders nützlich in Szenarien, in denen die Bestimmung des höchsten Wertes entscheidend für die Entscheidungsfindung ist. Durch effizientes Durchsuchen des Arrays gibt die Funktion den Index des maximalen Elements zurück, wobei die Array-Serie berücksichtigt wird. In Situationen, in denen das Array finanzielle oder technische Daten darstellt, ist die Ermittlung des Maximalwerts ein grundlegender Schritt, um aussagekräftige Erkenntnisse zu gewinnen oder fundierte Handelsentscheidungen zu treffen.

Analogie

Stellen Sie sich vor, Sie haben eine Liste mit Zahlen, z. B. die Punktzahlen verschiedener Spiele, die Sie gespielt haben. Die Funktion „ArrayMaximum()“ ist wie ein kleiner Helfer, der Ihre Liste durchsucht und Ihnen sagt, in welchem Spiel Sie am besten abgeschnitten haben. Wenn Sie also wissen wollen, welches Spiel die höchste Punktzahl hatte, prüft dieser Helfer jede Punktzahl, und wenn er die höchste findet, zeigt er auf dieses Spiel und sagt: „Das ist Ihr bestes Spiel!“ Es ist, als würde ein Freund schnell das Spiel finden, in dem Sie am besten abgeschnitten hast, ohne dass Sie selbst die ganze Liste durchgehen musst. In Computerprogrammen ist dieses Hilfsmittel nützlich, um die größte Zahl in einer Reihe von Zahlen zu finden.

Syntax:

int ArrayMaximum(
    array[],       // Array for search
    start,          // Index to start checking with
    count = WHOLE_ARRAY    // Number of checked elements (default: search in the entire array)
);

Parameter:

• „array[]“: Dies ist das Array, für das Sie den Maximalwert finden möchten.
• „start“: Mit diesem Parameter können Sie den Index im Array angeben, ab dem Sie die Suche nach dem Maximalwert beginnen möchten.
• „count = WHOLE_ARRAY“: Sie gibt die Anzahl der Elemente an, die bei der Suche berücksichtigt werden sollen. Der Standardwert „WHOLE_ARRAY“ bedeutet, dass die Funktion im gesamten Array sucht.

Wenn Sie nun „ArrayMaximum(array, start, count)“ aufrufen, findet die Funktion das größte Element im angegebenen Bereich des Arrays und gibt dessen Index zurück. Wenn kein Maximum gefunden wird, wird -1 zurückgegeben.

Beispiel:

void OnStart()
  {
  
// Declare an array with integer values
   int myArray[] = {42, 18, 56, 31, 75, 23};

// Find the maximum value and its index
   int maxIndex = ArrayMaximum(myArray);

// Check if a maximum was found
   if(maxIndex != -1)
     {
      Print("The maximum value in the array is: ", myArray[maxIndex]);
      Print("Index of the maximum value: ", maxIndex);
     }
   else
     {
      Print("No maximum value found in the array.");
     }

  }

Erläuterung:

„int myArray[] = {42, 18, 56, 31, 75, 23};“:

• Diese Zeile deklariert ein Integer-Array mit dem Namen „myArray“ und initialisiert es mit sechs Integer-Werten.

„int maxIndex = ArrayMaximum(myArray);“:

• Die Funktion „ArrayMaximum()“ wird für „myArray“ aufgerufen, um den Index des höchsten Wertes im Array zu ermitteln. Das Ergebnis wird in der Variablen „maxIndex“ gespeichert.

„if (maxIndex != -1) {“:  

• Diese bedingte Anweisung prüft, ob ein Maximalwert gefunden wurde. Wenn „maxIndex“ ungleich „-1“ ist, bedeutet dies, dass ein Maximalwert im Array existiert.

„Print("The maximum value in the array is: ", myArray[maxIndex]);“:

• Wenn ein Maximalwert gefunden wird, wird in dieser Zeile der Maximalwert unter Verwendung des aus „maxIndex“ erhaltenen Index ausgedruckt.

„Print("Index of the maximum value: ", maxIndex);“:

• In dieser Zeile wird der Index des Höchstwerts gedruckt.

„} else { Print("No maximum value found in the array."); }“:

• Wenn maxIndex -1 ist, was der Fall ist, wenn kein Maximalwert gefunden wurde, wird dieser Block ausgeführt und eine Meldung ausgegeben, dass kein Maximalwert gefunden wurde.

Um den Maximalwert und seinen Index in einem Array zu bestimmen, verwenden Sie „ArrayMaximum()“, wie dieser Code veranschaulicht.

13. ArrayMinimum

Eine nützliche Funktion in MQL5 namens „ArrayMinimum()“ lässt Sie den Index des kleinsten (minimalen) Elements in der ersten Dimension eines numerischen Arrays bestimmen. Diese Funktion arbeitet mit Arrays unterschiedlicher Größe und ist sehr flexibel. Es gewährleistet genaue Ergebnisse, indem es die serielle Reihenfolge des Arrays berücksichtigt.

„ArrayMinimum()“ wird in erster Linie verwendet, um den Index des kleinsten Elements im Array zu ermitteln. Sie gibt den Index des niedrigsten Wertes an, wobei die Reihenfolge der Elemente des Arrays berücksichtigt wird. Die Funktion gibt -1 zurück, wenn bei der Suche kein Mindestwert gefunden wird. Wenn Sie die genaue Position des kleinsten Elements innerhalb eines Arrays bestimmen müssen, kann diese Funktion sehr nützlich sein.

Syntax:

int ArrayMinimum(array[],start,count = WHOLE_ARRAY);

Beispiel:

void OnStart()
  {

// Declare an integer array
   int myArray[] = {10, 5, 8, 3, 12};

// Find the index of the minimum element in the entire array
   int minIndex = ArrayMinimum(myArray, 0, WHOLE_ARRAY);

// Print the result
   Print("Index of the minimum element: ", minIndex);

  }

Genau wie in „ArrayMaximum()“ findet dieser Code den Index des kleinsten Elements im gesamten „myArray“ und gibt das Ergebnis aus.

Schlussfolgerung

In diesem Artikel haben Sie die Welt der Array-Funktionen in MQL5 besprochen und ihre Funktionalitäten und Anwendungen aufgedeckt. Von der Suche und dem Kopieren bis hin zur Größenänderung und der Handhabung von Zeitreihen-Arrays haben Sie eine Vielzahl von Funktionen untersucht, darunter ArrayBsearch, ArrayCopy, ArrayCompare, ArrayResize, ArrayFree, ArraySetAsSeries, ArrayGetAsSeries, ArrayInitialize, ArrayFill, ArrayIsDynamic, ArrayIsSeries, ArrayMaximum und ArrayMinimum Jede Funktion spielt eine entscheidende Rolle bei der Manipulation von Arrays und der Verbesserung der Fähigkeiten von Handelsalgorithmen.

Zum Abschluss dieses Artikels ist es wichtig zu erwähnen, dass ich absichtlich nicht alle Array-Funktionen behandelt habe, um eine konzentrierte und verständliche Lernerfahrung zu gewährleisten. Der nächste Artikel wird die anderen Array-Funktionen wie ArrayPrint, ArrayRange, ArrayInsert, ArrayRemove, ArrayReverse, ArraySize, ArraySort, ArraySwap, ArrayToFP16,  ArrayToFP8,  ArrayFromFP16 und ArrayFromFP8 erweitern. Dieser schrittweise Ansatz soll eine reibungslosere Lernkurve ermöglichen. Also, schnallen Sie sich an für den nächsten Teil, in dem Sie Ihre Erkundung der MQL5-Array-Funktionen fortsetzen werden!