Lernen Sie, wie man mit Datum und Uhrzeit in MQL5 umgeht

Einführung

Niemandem im Finanzmarktbereich bleibt es verborgen, wie wichtig die Zeit ist und wie sie Handelsentscheidungen und -ergebnisse beeinflussen kann. MQL5 (MetaQuotes Language 5) bietet eine erstaunliche Lösung, um effektiv mit Datum und Uhrzeit umzugehen, und das werden wir in diesem Artikel lernen, denn wir werden sehen, wie wir mit diesem wichtigen Thema durch viele Anwendungen umgehen können, die als Teil unseres Handelssystems codiert werden können, nachdem wir die wichtigsten Aspekte dieses Themas in der Programmiersprache MQL5 verstanden haben.

Die folgenden Themen werden wir in diesem Artikel behandeln:

• Der Typ datetime
• Die Struktur MqlDateTime
• OnTimer-Ereignis
• NewBar-Anwendung
• Anwendung des Zeitfilters
• tradeAtTime-Anwendung
• Schlussfolgerung

Durch das Lesen dieser Themen wird davon ausgegangen, dass Sie in der Lage sein werden, den Datentyp „datetime“ in Ihrer Mql5-Software als Teil aller von Ihnen erstellten Daten zu verwenden, da das Thema „Datum/Uhrzeit“, wie bereits erwähnt, ein sehr wichtiges Thema ist den Handel und Sie müssen verstehen, wie man als Händler oder Handelssystementwickler damit umgeht. Ich hoffe also, dass Sie diesen Artikel nützlich finden und Einblicke in das Thema oder zumindest in ein verwandtes Thema erhalten.

Haftungsausschluss: Alle Informationen werden in der vorliegenden Form nur zu Informationszwecken bereitgestellt und sind nicht für Handelszwecke oder als Ratschläge gedacht. Die Informationen garantieren keinen Erfolg. Wenn Sie sich dafür entscheiden, diese Materialien auf einem Ihrer Handelskonten zu verwenden, tun Sie dies auf eigenes Risiko und Sie sind allein verantwortlich.

Der Typ datetime

Der Variablentyp datetime in mql5 wird verwendet, um Daten mit Datum und Uhrzeit in Unix-Zeit zu sortieren. Die Unix-Zeit ist die Anzahl der seit dem 1. Januar 1970 verstrichenen Sekunden. Zum besseren Verständnis: Wenn wir das Datum des 01. Januar 2023 um 00:00:00 GMT in Unix-Zeit konvertieren wollen, können wir feststellen, dass es 1672531200 Sekunden sind. Dementsprechend ist der Zeitstempel die Anzahl der Sekunden zwischen einem bestimmten Datum und der Unix-Epoche, also dem 1. Januar 1970. Wir können auch die Zeit in Sekunden im Vergleich zu der bekannten lesbaren Zeit wie folgt sehen:

Bekannte lesbare Zeit	Sekunden
1 Jahr	31556926 Sekunden
1 Monat	2629743 Sekunden
1 Woche	604800 Sekunden
1 Tag	86400 Sekunden
1 Stunde	3600 Sekunden

Es gibt interessante Informationen über das Thema Unix-Zeit, wenn Sie mehr darüber lesen wollen, lesen Sie den Wikipedia-Artikel über die Unixzeit.

Es kann sein, dass wir ein bestimmtes Datum und eine bestimmte Uhrzeit festlegen müssen. Dies ist sehr einfach, indem wir die datetime-Konstante verwenden, die mit dem Zeichen D beginnt, wobei das Datum und die Uhrzeit in einfachen Anführungszeichen stehen, wie im folgenden Format:

D'yyyy.mm.dd hh:mm:ss'

Oder:

D'dd.mm.yyyy hh:mm:ss'

Die folgenden Beispiele aus der mql5-Referenz können in diesem Zusammenhang eine nützliche Hilfe sein:

datetime NY=D'2015.01.01 00:00';     // Time of beginning of year 2015
datetime d1=D'1980.07.19 12:30:27';  // Year Month Day Hours Minutes Seconds
datetime d2=D'19.07.1980 12:30:27';  // Equal to D'1980.07.19 12:30:27';
datetime d3=D'19.07.1980 12';        // Equal to D'1980.07.19 12:00:00'
datetime d4=D'01.01.2004';           // Equal to D'01.01.2004 00:00:00'
datetime compilation_date=__DATE__;             // Compilation date
datetime compilation_date_time=__DATETIME__;    // Compilation date and time
datetime compilation_time=__DATETIME__-__DATE__;// Compilation time
//--- Examples of declarations after which compiler warnings will be returned
datetime warning1=D'12:30:27';       // Equal to D'[date of compilation] 12:30:27'
datetime warning2=D'';               // Equal to __DATETIME__

Die folgenden Angaben beziehen sich auf gedruckte Ergebnisse nach der Kompilierung:

Genauso wie wir bisher verstanden haben, dass der Typ datetime Datums- und Zeitwerte in der Anzahl von Sekunden enthält. Dies erleichtert den Vergleich oder die Manipulation von Datums- und Zeitwerten. Im Folgenden finden Sie Beispiele für den Umgang mit Datums- und Zeitwerten:

• Vergleich der Werte von Datum und Uhrzeit.
• Addieren oder Subtrahieren von Datums- und Zeitwerten.
• Konvertierung von Zeit in Zeichenketten oder Zeichenketten in Zeit für andere Zwecke.

Vergleich der Werte von Datum und Uhrzeit:

Wenn wir zwei Zeit- und Datumswerte haben und sie für andere Zwecke vergleichen müssen, können wir das in MQL5 tun, indem wir für jeden Wert eine Variable erstellen und sie dann miteinander vergleichen, um auf der Grundlage des Ergebnisses eine Aktion durchzuführen. Im Folgenden wird ein Beispiel für diesen Fall gegeben:

Wenn der Nutzer zwei Werte für Datum und Uhrzeit eingibt, von denen einer älter ist als der andere, und wir ein bestimmtes Ergebnis erhalten möchten, z. B. eine Druckanweisung, wenn der Wert von Eingabe eins größer ist als der Wert von Eingabe zwei, dann müssen wir die Meldung „Eingabe eins ist eine aktuelle Zeit“ erhalten, aber wenn der Wert von Eingabe eins kleiner ist als der Wert von Eingabe zwei, dann müssen wir die Meldung „Eingabe zwei ist eine aktuelle Zeit“ erhalten.

Im Folgenden finden Sie den entsprechenden Code:

//+------------------------------------------------------------------+
//|                                              dateTimeCompare.mq5 |
//+------------------------------------------------------------------+
input datetime inpDate1 = D'2023.09.01 00:00';
input datetime inpDate2 = D'2023.09.30 00:00';
//+------------------------------------------------------------------+
void OnTick()
  {
   if(inpDate1>inpDate2)
     {
      Print("Input one is a recent time");
     }
   else
      if(inpDate1<inpDate2)
        {
         Print("Input two is a recent time");
        }
  }
//+------------------------------------------------------------------+

Nach dem Kompilieren dieses Codes, wenn wir Datum und Zeit Eingabe Werte die gleiche wie die folgenden:

Wie wir sehen können, ist die Eingabe1 älter als die zweite. Das Ergebnis ist also dasselbe wie das folgende:

Wenn wir die erste Eingabe so ändern, dass sie aktueller ist als die zweite, sieht es wie folgt aus:

Nach den vorherigen Einstellungen der Eingänge müssen wir das Ergebnis wie folgt finden:

Das vorangegangene Codebeispiel ist ein Beispiel dafür, wie wir mit Datum und Uhrzeit als Vergleich umgehen können.

Addieren oder Subtrahieren von Datums- und Zeitwerten:

Wir können auch zu Datums- und Zeitwerten addieren oder subtrahieren. Nehmen wir an, wir haben zwei Datums- und Zeitwerte wie die folgenden:

D'2023.09.01 00:00'
D'2023.09.30 00:00'

Nun müssen wir einen Tag zum ersten Wert addieren und einen Tag vom zweiten Wert subtrahieren. Ein Tag in Sekunden ist gleich 86400, sodass wir nach diesen beiden Transaktionen die neuen Werte wie folgt finden:

D'2023.09.02 00:00'
D'2023.09.29 00:00'

Der folgende Code zeigt, wie diese Transaktionen zu kodieren sind:

//+------------------------------------------------------------------+
//|                                           dateTimeManipulate.mq5 |
//+------------------------------------------------------------------+
input datetime oldDate = D'2023.09.01 00:00';
input datetime newDate = D'2023.09.30 00:00';
//+------------------------------------------------------------------+
void OnTick()
  {
   datetime addToDate =   oldDate+86400;
   Print("Result of date addition - ",addToDate);
   datetime subtractFromDate =   newDate-86400;
   Print("Result of date subtraction - ",subtractFromDate);
  }
//+------------------------------------------------------------------+

Das Ergebnis der Ausführung dieser Software wird das gleiche sein, wie wir es im Folgenden beschrieben haben:

Konvertierung von Zeit (datetime) in Zeichenketten (string) oder Zeichenketten in Zeit für andere Zwecke:

Es kann vorkommen, dass wir den Typ von Datums- und Zeitwerten konvertieren müssen. Zu diesem Zeitpunkt haben wir zwei Funktionen, die sich mit der Konvertierung zwischen string und datetime befassen können. Entweder TimeToString oder StringToTime, wir werden jetzt in diesem Teil ein Beispiel sehen, wie wir mit einem solchen Fall umgehen können, wie der folgende Code:

//+------------------------------------------------------------------+
//|                                              dateTimeConvert.mq5 |
//+------------------------------------------------------------------+
input datetime oldDate = D'2023.09.01 00:00';
input string newDate = "2023.09.30 00:00";
//+------------------------------------------------------------------+
void OnTick()
  {
   string newOldDate = TimeToString(oldDate);
   datetime newNewDate = StringToTime(newDate);
   Print("Time To String - ",newOldDate);
   Print("String To Time - ",newNewDate);
  }
//+------------------------------------------------------------------+

Wenn wir diesen Code im Handelsterminal ausführen, finden wir die zurückgegebenen Werte für jede Funktion, die erste für die Konvertierung von TimeToString und die zweite für die Konvertierung von StringToTime, wie im Folgenden beschrieben:

Allgemein gesprochen, wenn wir alle Operationen des Datentyps datetime in MQL5 kennen und verstehen wollen,

• currentTime: um die aktuelle Zeit zurückzugeben.
• Vergleich zwischen Werten: Logischerweise verwenden wir diese Operation, um den Zeitvergleich zu überprüfen.
• Manipulation mit Datums- und Zeitangaben: wie Addition und Veränderungen.
• Datum und Uhrzeit formatieren.

Die Struktur MqlDateTime

In diesem Teil werden wir die Struktur MqlDateTime kennenlernen. Sie enthält Variablen, die Daten von Datum und Uhrzeit oder Datetime-Werte enthalten können. Im Folgenden ist die Struktur, über die die MQL5-Referenz verfügt:

struct MqlDateTime
  {
   int year;           // Year
   int mon;            // Month
   int day;            // Day
   int hour;           // Hour
   int min;            // Minutes
   int sec;            // Seconds
   int day_of_week;    // Day of week (0-Sunday, 1-Monday, ... ,6-Saturday)
   int day_of_year;    // Day number of the year (January 1st is assigned the number value of zero)
  };

Wie wir sehen können, enthält sie acht Felder mit Variablen vom Typ int.

Wir verwenden die Funktion (TimeToStruct) mit dieser Struktur, um den Datumswert in eine Variable des Typs MqlDateTime umzuwandeln; die Parameter dieser Funktion sind

• dt: Datum und Uhrzeit
• dt_struct: Struktur für die Übernahme von Werten

Diese Funktion gibt einen booleschen Wert zurück.

Wir können auch die Funktion (StructToTime) verwenden, um die Variable der Struktur MqlDateTime in einen Datetime-Wert umzuwandeln. Ihr Parameter ist nur dt_struct. Sie gibt den Typ datetime zurück, der die Anzahl der Sekunden enthält.

Wir können ein Beispiel für diese MqlDateTime-Struktur wie das folgende sehen:

Wenn wir die Datumszeit D'2023.10.10 07:07:07' oder einen anderen Eingabewert haben, müssen wir MqlDateTime dafür verwenden. Wir können dies mit dem folgenden Code tun:

//+------------------------------------------------------------------+
//|                                                  MqlDateTime.mq5 |
//+------------------------------------------------------------------+
input datetime dtData = D'2023.10.10 07:07:07';
void OnTick()
  {
   MqlDateTime timeStruct;
   TimeToStruct(dtData,timeStruct);
   int year = timeStruct.year;
   Print("year: ",year);
   Print("=====================");
   int month = timeStruct.mon;
   Print("month: ",month);
   Print("=====================");
   int day = timeStruct.day;
   Print("day: ",day);
   Print("=====================");
   int hour = timeStruct.hour;
   Print("hour: ",hour);
   Print("=====================");
   int minute = timeStruct.min;
   Print("minute: ",minute);
   Print("=====================");
   int second = timeStruct.sec;
   Print("second: ",second);
   Print("=====================");
   int dayofWeek = timeStruct.day_of_week;
   Print("dayofWeek: ",dayofWeek);
   Print("=====================");
   int dayofYear = timeStruct.day_of_year;
   Print("dayofYear: ",dayofYear);
  }
//+------------------------------------------------------------------+

Wenn man diesen EA ausführt, findet man die folgenden gedruckten Meldungen:

Es ist gut, hier zu erwähnen, dass der Standardwert für den Monat oder den Tag 01 ist, wenn Sie weniger als 1 als Eingabe verwenden. Der maximale Standardwert für den Monat ist 12 und für den Tag 31, wenn die verwendbare Eingabe größer als dieser maximale Wert ist. Die Standardwerte für Stunden sind mindestens 0 und höchstens 23 und für Minuten mindestens 0 und höchstens 59.

Das OnTimer() Ereignis

In diesem Teil werden wir lernen, was die Ereignisbehandlung durch OnTimer() ist und wie wir ihn verwenden können. Es kann verwendet werden, wenn Sie Ihren Code oder Ihre Handelsstrategie in einer bestimmten Anzahl von Sekunden ausführen lassen wollen. Wenn Sie also möchten, dass Ihr Code eine bestimmte Aktion in einem bestimmten Zeitintervall ausführt, können Sie Ihren Code in der Funktion OnTimer() platzieren.

Das OnTimer()-Ereignis ist ein void-Typ ohne Parameter und kann dem Code hinzugefügt werden, wenn Sie es benötigen. Um ihn zu verwenden, müssen Sie das Zeitintervall des Timers in OnInit() mit dem Befehl EventSetTimer() mit dem Sekunden-Parameter einstellen, so wie im folgenden Beispiel:

int OnInit()
{
EventSetTimer(60);
}

Das vorherige Beispiel bedeutet, dass der Code innerhalb von OnTimer() alle 60 Sekunden ausgeführt wird.

Wenn wir nun die Ausführung des Codes innerhalb von OnTimer() stoppen müssen, können wir dies mit der Funktion vom Typ void EventKillTimer() im onDeinit() oder im Destruktor der Klasse tun.

NewBar-Anwendung

In dieser Anwendung werden wir eine Include-Datei erstellen, die Klassen und Funktionen enthält, die in anderen Dateien wie EAs verwendet werden können, um unser Ziel zu erreichen, nämlich zu melden, ob ein neuer Balken vorliegt, indem wir die Meldung „A new bar painted“ ausgeben.

Die folgenden Schritte dienen zunächst der Erstellung der Include-Datei. Die Hauptidee hinter der Erstellung der Include-Datei ist es, zu lernen und sich an die Erstellung von Dateien zu gewöhnen, die in vielen Projekten verwendet werden können, und professionell als Entwickler zu arbeiten, wenn Sie ein Anfänger sind.

Wir deklarieren die Klasse CNewBar, die über zwei private Variablen verfügt (time[] zum Speichern der Zeit des aktuellen Balkens und die andere Variable lastTime zum Speichern der Zeit des letzten Balkens). Wir werden eine Methode der booleschen Funktion newBarCheck mit zwei Parametern integrieren:

• Symbol String-Typ
• timeFrame ENUM_TIMEFRAMES type

class CNewBar
  {
private:
   datetime          time[], lastTime;
public:
   void              CNewBar();
   bool              newBarCheck(string symbol, ENUM_TIMEFRAMES timeFrame);
  };

Einstellen der Zeitreihe als Serie

void CNewBar::CNewBar(void)
  {
   ArraySetAsSeries(time,true);
  }

Erstellen der Funktion newBarCheck mit zwei Parametern (Symbol und timeFrame), um zu prüfen, ob ein neuer Balken vorhanden ist oder nicht, die Funktion gibt einen Wert vom Typ bool zurück:

bool CNewBar::newBarCheck(string symbol, ENUM_TIMEFRAMES timeFrame)

Der Hauptteil der Funktion prüft, ob ein neuer Balken vorhanden ist, und erstellt zwei bool-Variablen für first und newBar mit einem Standardwert false:

   bool firstCheck = false;
   bool newBar = false;

Die Verwendung der Funktion CopyTime mit den Varianten des Aufrufs an der ersten Position, um die time_array-Historiendaten der Balkeneröffnungszeit des angegebenen Symbol-Perioden-Paares in der angegebenen Menge zu erhalten. Die Parameter sind:

• symbol_name: zur Angabe des Symbolnamens, der als definierte Zeichenkette in der Funktion symbolisiert wird.
• timeframe: zur Angabe des Zeitrahmens, der in der Funktion ENIM_TIMEFRAMES als timeFrame definiert wird.
• start_pos: zur Angabe der Startposition, die 0 sein wird.
• count: zur Angabe der zu kopierenden Daten, die 2 sein werden.
• time_array[]: das Array, aus dem die offenen Zeiten kopiert werden, wird das Zeit-Array sein.

CopyTime(symbol,timeFrame,0,2,time);

Wir werden die Klassenvariable lastTime prüfen. Wenn es das erste Mal ist, dass wir prüfen, wird der Wert der Variablen lastTime gleich 0 sein und die Variable firstCheck wird wahr sein.

   if(lastTime == 0)
     {
      firstCheck = true;
     }

Prüfen, ob time[0] größer ist als lastTime, dann prüfen, ob der Wert von firstCheck false ist, dann ist newBar true und lastTime hat denselben Wert wie time[0]:

   if(time[0] > lastTime)
     {
      if(firstCheck == false)
      {
         newBar = true;
      }
      lastTime = time[0];
     }

Rückgabe des Wertes von newBar, einem booleschen Wert:

return(newBar);

Im Folgenden finden Sie den vollständigen Code dieser Include-Datei in einem einzigen Code-Block:

//+------------------------------------------------------------------+
//|                                                       newBar.mqh |
//+------------------------------------------------------------------+
class CNewBar
  {
private:
   datetime          time[], lastTime;
public:
   void              CNewBar();
   bool              newBarCheck(string symbol, ENUM_TIMEFRAMES timeFrame);
  };
//+------------------------------------------------------------------+
void CNewBar::CNewBar(void)
  {
   ArraySetAsSeries(time,true);
  }
//+------------------------------------------------------------------+
bool CNewBar::newBarCheck(string symbol, ENUM_TIMEFRAMES timeFrame)
  {
   bool firstCheck = false;
   bool newBar = false;
   CopyTime(symbol,timeFrame,0,2,time);
   if(lastTime == 0)
     {
      firstCheck = true;
     }
   if(time[0] > lastTime)
     {
      if(firstCheck == false)
      {
         newBar = true;
      }
      lastTime = time[0];
     }
   return(newBar);
  }
//+------------------------------------------------------------------+

Wenn Sie mehr über die objektorientierte Programmierung (OOP) und Klassen in MQL5 erfahren möchten, können Sie mehr darüber in meinen früheren Artikel Objektorientierte Programmierung (OOP) lesen, der Ihnen vielleicht nützlich ist.

Nachdem wir die Datei erstellt haben, werden wir unseren EA erstellen, der den neuen Balken erkennt und die Meldung „A new bar painted, you can trade“ (Ein neuer Balken wurde erstellt, Sie können handeln) ausgibt. Zuerst werden wir die erstellte Include-Datei in den EA-Code mit der Präprozessor-Direktive #include einbinden:

#include <dateTime.mqh>

Deklaration von einem Objekt der Klasse CNewBar:

CNewBar NewBar;

Erstellen einer boolschen Variable als Eingabe, um zu wählen, ob gehandelt werde soll, wenn ein neuer Balken gezeichnet wird (true) oder nicht (false):

bool newBarTrade=true;

Danach wird in OnTick() eine boolsche Variable newBar mit dem Standardwert true und eine weitere Integer-Variable barShift mit dem Standardwert 0 erstellt:

   bool newBar=true;
   int barShift=0;

Wenn newBarTrade wahr ist, wird der Variablen newBar Newbarobject.newBarCheck mit den Parametern des aktuellen Symbols und des aktuellen Zeitrahmens und barShift gleich 1 zugewiesen.

   if(newBarTrade==true)
     {
      newBar = NewBar.newBarCheck(Symbol(),Period());
      barShift=1;
     }

Wenn newBar wahr ist, bedeutet dies, dass ein neuer Balken erzeugt wurde, sodass wir die Meldung „A new bar painted, you can trade“ (Ein neuer Balken wurde erstellt, Sie können handeln) erhalten.

   if(newBar==true)
     {
      Print("A new bar painted, you can trade");
     }

Im Folgenden finden Sie den vollständigen Code für diese Anwendung in einem einzigen Codeblock:

//+------------------------------------------------------------------+
//|                                                       newBar.mq5 |
//+------------------------------------------------------------------+
#include <dateTime.mqh>
CNewBar NewBar;
bool newBarTrade=true;
//+------------------------------------------------------------------+
void OnTick()
  {
   bool newBar=true;
   int barShift=0;
   if(newBarTrade==true)
     {
      newBar = NewBar.newBarCheck(Symbol(),Period());
      barShift=1;
     }
   if(newBar==true)
     {
      Print("A new bar painted, you can trade");
     }
  }
//+------------------------------------------------------------------+

Nach der Ausführung dieses EA, können wir das folgende Ergebnis zu finden, sobald ein neuer Balken erzeugt wurde:

Dieser Code kann weiterentwickelt werden, um die Aktion zu ändern, wenn ein neuer Balken nach Ihrer Strategie neu erstellt wird, um zum Beispiel einen Handel oder etwas anderes zu öffnen, aber wir teilen in diesem Artikel einfachen Code, um die Hauptidee des Codes verständlich zu machen und Sie können ihn nach Bedarf ändern.

Anwendung des Zeitfilters

In dieser Anwendung müssen wir eine Filteranwendung erstellen, die verwendet werden kann, um den Handel auf der Grundlage eines Zeitfilters oder eines bestimmten Zeitraums zu erlauben oder zu verhindern. Wir fügen der erstellten Include-Datei eine neue Klasse namens CTimeFilter hinzu und erstellen eine öffentliche Funktion bool timeCheck mit drei Parametern, startTime, endTime und localTime, mit dem Standardwert false.

class CTimeFilter
  {
public:
   bool timeCheck(datetime startTime, datetime endTime, bool localTime = false);
  };

Erstellen wir den Hauptteil der Funktion timeCheck, indem wir prüfen, ob die Dateneingabe falsch war, indem wir startTime größer oder gleich endTime erhalten, und dann eine Fehlermeldung „Error Invalid Time input“ (Ungültige Zeiteingabe) ausgeben und false zurückgeben:

   if(startTime >= endTime)
     {
      Alert("Error: Invalid Time input");
      return(false);
     }

Erstellen einer Datetime-Variable für die aktuelle Zeit und anschließende Überprüfung, ob die lokale Zeit wahr ist, wobei TimeLocal() der aktuellen Zeit oder TimeCurrent() der aktuellen Zeit zugewiesen wird:

   datetime currentTime;
   if(localTime == true)
     {
      currentTime = TimeLocal();
     }
   else
      currentTime = TimeCurrent();

Erstellen einer booleschen Variablen namens timeFilterActive mit dem Standardwert false und der anschließenden Prüfung, ob die currentTime größer oder gleich der startTime und gleichzeitig kleiner als die endTime ist, dann Rückgabe von true für timeFilterActive:

   bool timeFilterActive = false;
   if(currentTime >= startTime && currentTime < endTime)
     {
      timeFilterActive = true;
     }
   return(timeFilterActive);

Im Folgenden ist der gesamte Code in der Include-Datei in einem Block dargestellt:

class CTimeFilter
  {
public:
   bool timeCheck(datetime startTime, datetime endTime, bool localTime = false);
  };
bool CTimeFilter::timeCheck(datetime startTime, datetime endTime, bool localTime = false)
  {
   if(startTime >= endTime)
     {
      Alert("Error: Invalid Time input");
      return(false);
     }
   datetime currentTime;
   if(localTime == true)
     {
      currentTime = TimeLocal();
     }
   else
      currentTime = TimeCurrent();
   bool timeFilterActive = false;
   if(currentTime >= startTime && currentTime < endTime)
     {
      timeFilterActive = true;
     }
   return(timeFilterActive);
  }

Nachdem wir die Include-Datei erstellt haben, werden wir im folgenden Schritt unsere timeFilterApp EA erstellen:

Die dateTime-Datei einbinden, um ihren Inhalt zu verwenden:

#include <dateTime.mqh>

 Erstellen von zwei Datumsvariablen als Eingabewerte namens StartTime und EndTime:

input datetime StartTime = D'2023.10.10 10:00';
input datetime EndTime = D'2023.10.10 17:00';

Erstellen eines Objekts namens filter im globalen Bereich:

CTimeFilter filter;

Wir erstellen von timeFilterActive in OnTick() und weisen ihr filter.timeCheck mit seinen Parametern zu:

bool timeFilterActive = filter.timeCheck(StartTime,EndTime,false);

Um zu überprüfen, ob der timeFilterActive wahr ist, müssen wir die Meldung „Trading is active based on time filter“ (Der Handel ist aktiv, basierend auf dem Zeitfilter) oder die Meldung „Trading is inactive based on time filter“ (Der Handel ist inaktiv, basierend auf dem Zeitfilter) erhalten:

   if(timeFilterActive == true)
     {
      Print("Trading is active based on time filter");
     }
     else Print("Trading is inactive based on time filter");

Im Folgenden ist der vollständige Code in einem Block dargestellt:

//+------------------------------------------------------------------+
//|                                                timeFilterApp.mq5 |
//+------------------------------------------------------------------+
#include <dateTime.mqh>
input datetime StartTime = D'2023.10.10 10:00';
input datetime EndTime = D'2023.10.10 17:00';
CTimeFilter filter;
void OnTick()
  {
   bool timeFilterActive = filter.timeCheck(StartTime,EndTime,false);
   if(timeFilterActive == true)
     {
      Print("Trading is active based on time filter");
     }
     else Print("Trading is inactive based on time filter");
  }

Nach der Ausführung dieser Anwendung können wir je nach Zeitangabe eines von drei Ergebnissen finden.

Im Falle der aktiven Zeit:

Im Falle einer inaktiven Zeit:

Im Falle falscher Eingaben:

Es gibt eine weitere Methode, ohne eine Include-Datei verwenden zu müssen:

Wir erstellen vier Integer-Variablen als Eingabe für die Anfangsstunde und -minute sowie die Endstunde und -minute:

input int TimeStartHour = 
10 ;
input int TimeStartMin = 0;
input int TimeEndHour = 17;
input int TimeEndMin = 
0 ;

In OnTick() erstellen wir die Variable structTime mit der Funktion MqlDateTime, die Datums- und Zeitdaten enthält:

MqlDateTime structTime;

Wir übergeben die erstellte structTime-Variable an die Funktion TimeCurrent:

TimeCurrent(structTime);

Einstellung der Sekunde auf 0, der Stunde und der Minuten für die Startzeit:

   structTime.sec = 0;
   structTime.hour = TimeStartHour;
   structTime.min = TimeStartMin;

Wir erstellen eine Datetime-Variable für timeStart und übergeben structTime an die Funktion StructToTime, die eine Strukturvariable MqlDateTime in einen Wert vom Typ datetime umwandelt und ihn dann der Variablen timeStart zuweist:

datetime timeStart = StructToTime(structTime);

Einstellung von Stunde und Minute für die Endzeit:

   structTime.hour = TimeEndHour;
   structTime.min = TimeEndMin;

Erstellen der timeEnd-Variable auf die gleiche Weise wie bei timeStart:

datetime timeEnd = StructToTime(structTime);

Wir erstellen die booleschen Variable isTime, um die zulässige Zeit für den Handel zu bestimmen:

bool isTime = TimeCurrent() >= timeStart && TimeCurrent() < timeEnd;

Erstellen der Fehlermeldung bei falschen Eingaben:

   if(TimeStartHour >= TimeEndHour)
     {
      Print("Error: Invalid Time input");
     }

Festlegung der Bedingungen für die Handelszeit:

   if(isTime==true)
     {
      Print("Trading is active based on time filter");
     }
   else
      Print("Trading is inactive based on time filter");

Im Folgenden finden Sie den vollständigen Code in einem Block:

//+------------------------------------------------------------------+
//|                                               timeFilterApp2.mq5 |
//+------------------------------------------------------------------+
input int TimeStartHour = 10;
input int TimeStartMin = 0;
input int TimeEndHour = 17;
input int TimeEndMin = 0;
//+------------------------------------------------------------------+
void OnTick()
  {
   MqlDateTime structTime;
   TimeCurrent(structTime);
   structTime.sec = 0;
   structTime.hour = TimeStartHour;
   structTime.min = TimeStartMin;
   datetime timeStart = StructToTime(structTime);
   structTime.hour = TimeEndHour;
   structTime.min = TimeEndMin;
   datetime timeEnd = StructToTime(structTime);
   bool isTime = TimeCurrent() >= timeStart && TimeCurrent() < timeEnd;
   if(TimeStartHour >= TimeEndHour)
     {
      Print("Error: Invalid Time input");
     }
   if(isTime==true)
     {
      Print("Trading is active based on time filter");
     }
   else
      Print("Trading is inactive based on time filter");
  }
//+------------------------------------------------------------------+

Die Ausführung dieses Codes führt zu den folgenden Ergebnissen:

Im Falle von aktiv:

Im Falle einer inaktiven Zeit zum Handeln:

Im Falle von Fehleingaben:

Die Anwendung tradeAtTime

Angenommen, wir müssen eine bestimmte Zeit festlegen, zu der wir nur handeln dürfen, dann müssen wir diese Zeit als erlaubte Zeit für den Handel festlegen. Dafür sind folgenden Schritte notwendig.

Erstellen einer Eingabezeichenfolge vom Typ openTime-Variable mit einem Standardwert „10:00“ global:

input string openTime="10:00";

Erstellen einer Datetime-Variable für lastTime:

datetime lastTime;

In OnTick() erstellen wir die Datumsvariable dtOpenTime, um ihr die StringToTime-Werte der openTime zuzuweisen:

datetime dtOpenTime=StringToTime(openTime);

Wenn die letzte erlaubte Zeit nicht gleich dtOpenTime ist und gleichzeitig timeCurrent() größer als dtOpenTime ist, müssen wir den Wert von lastTime mit dtOpenTime aktualisieren und die Meldung „Now is the allowed time to trade“ (Jetzt kann gehandelt werden) ausdrucken: Diese gedruckte Nachricht wird nur einmal zur angegebenen Zeit gedruckt.

   if(lastTime !=dtOpenTime && TimeCurrent()>dtOpenTime)
     {
      lastTime=dtOpenTime;
      Print("Now is the allowed time to trade");
     }

Im Folgenden finden Sie den vollständigen Code dieser Software:

//+------------------------------------------------------------------+
//|                                                  tradeAtTime.mq5 |
//+------------------------------------------------------------------+
input string openTime="10:00";
datetime lastTime;
//+------------------------------------------------------------------+
void OnTick()
  {
   datetime dtOpenTime=StringToTime(openTime);
   if(lastTime !=dtOpenTime && TimeCurrent()>dtOpenTime)
     {
      lastTime=dtOpenTime;
      Print("Now is the allowed time to trade");
     }
  }
//+------------------------------------------------------------------+

Nach der Ausführung des Codes können wir das gleiche Signal wie das folgende sehen:

Schlussfolgerung

Am Ende dieses Artikels hoffe ich, dass Sie verstanden haben, was datetime ist und wie wir mit Datum und Uhrzeit in MQL5 umgehen können, um eine Anpassung auf der Grundlage der Zeit vorzunehmen. Wir haben die „datetime“ in MQL5 identifiziert und wie wir sie verwenden können. Außerdem haben wir sie auf einfache Anwendungen angewendet, um unser Verständnis für dieses wichtige Thema zu verbessern. Diese Anwendungen können in jede Software integriert werden, um Datum und Uhrzeit effektiv zu verwalten. Es wird also davon ausgegangen, dass die folgende Themen verstanden wurde:

• Der Typ datetime
• Die Struktur MqlDateTime
• OnTimer-Ereignis
• NewBar-Anwendung
• Anwendung des Zeitfilters
• Die Anwendung tradeAtTime

Es gibt viele Anwendungen, die in Bezug auf Datum und Zeit in unserem Handel verwendet werden können, und wir sind nicht in der Lage, sie alle zu erwähnen, aber durch das Verständnis der Grundlagen des Themas können wir sie auf jede Anwendung anwenden, die wir brauchen.

Ich hoffe, dass Sie diesen Artikel nützlich und half Ihnen in der Reise des Lernens der MQL5 Programmiersprache, wenn Sie diesen Artikel nützlich und Sie brauchen, um mehr Artikel lesen können Sie meine Veröffentlichung, finden Sie Artikel über die Erstellung von Handelssystemen auf der Grundlage der beliebtesten technischen Indikatoren und andere Artikel im Zusammenhang mit dem Erlernen der MQL5 Programmiersprache und ich hoffe, dass Sie sie nützlich finden.