MQL4 · Migration MQL5
Remplacer Close[], Time[] et Bars en MQL5 : l’accès aux séries de prix
Les tableaux prédéfinis Open[], High[], Low[], Close[], Time[] et la variable Bars n’existent pas en MQL5. iClose, CopyRates et ArraySetAsSeries les remplacent : correspondances et code de portage.
En MQL4, les prix des bougies du graphique sont accessibles directement par des tableaux prédéfinis : Open[], High[], Low[], Close[], Time[] et Volume[], indexés à l’envers (l’indice 0 est la bougie en cours), complétés par la variable Bars qui donne le nombre de bougies disponibles. Ces tableaux n’existent pas en MQL5. Tout code qui écrit Close[1] ou Time[0] doit être adapté.
Deux familles de remplacements existent : les fonctions d’accès unitaire (iClose, iOpen, iHigh, iLow, iTime, iVolume, iBars), qui lisent une valeur à la fois, et les fonctions de copie (CopyRates, CopyClose, CopyTime…), qui remplissent un tableau. Cette page explique quand utiliser l’une ou l’autre, donne les correspondances et un code de portage.
Les correspondances
| MQL4 | MQL5, accès unitaire | MQL5, copie |
|---|---|---|
Open[i] | iOpen(_Symbol, _Period, i) | CopyOpen ou CopyRates (champ open) |
High[i] | iHigh(_Symbol, _Period, i) | CopyHigh ou CopyRates (champ high) |
Low[i] | iLow(_Symbol, _Period, i) | CopyLow ou CopyRates (champ low) |
Close[i] | iClose(_Symbol, _Period, i) | CopyClose ou CopyRates (champ close) |
Time[i] | iTime(_Symbol, _Period, i) | CopyTime ou CopyRates (champ time) |
Volume[i] | iVolume(_Symbol, _Period, i) (volume en ticks) | CopyTickVolume ou CopyRates (champ tick_volume) |
Bars | Bars(_Symbol, _Period) ou iBars(_Symbol, _Period) | — |
Les fonctions iClose, iTime et leurs voisines existent dans les deux langages. Leur présence en MQL5 simplifie beaucoup les migrations : un Close[i] peut être remplacé par iClose(_Symbol, _Period, i) dans le code MQL4 lui-même, testé, puis porté sans autre modification. La documentation de MQL5 précise que iClose renvoie 0 en cas d’erreur, et que chaque appel interroge la série sans mettre les résultats en cache ; si les données ne sont pas prêtes, le premier appel peut prendre un peu de temps.
Accès unitaire ou copie ?
L’accès unitaire convient quand on lit quelques valeurs : le prix de clôture de la bougie précédente, l’heure de la bougie en cours. Il donne un code très proche de l’original MQL4.
La copie convient quand on parcourt de nombreuses bougies : recherche d’un plus haut sur cinquante bougies, calcul d’une statistique, détection d’un motif. Une seule copie vers un tableau est plus efficace que cinquante appels successifs, et CopyRates récupère en une fois l’heure, les quatre prix, les volumes et le spread de chaque bougie dans une structure MqlRates.
Dans les deux cas, pensez à l’indexation. Les tableaux remplis par les fonctions de copie sont, par défaut, indexés du plus ancien au plus récent. Pour retrouver l’indexation de MQL4, où l’indice 0 est la bougie la plus récente, appelez ArraySetAsSeries(tableau, true) avant d’utiliser le tableau.
Exemple de portage : plus haut et plus bas des N dernières bougies
//+------------------------------------------------------------------+
//| MQL4 : boucle directe sur les tableaux prédéfinis |
//+------------------------------------------------------------------+
bool RangeMql4(const int n, double &hi, double &lo)
{
if(Bars < n + 1) return false; // historique insuffisant
hi = High[1];
lo = Low[1];
for(int i = 2; i <= n; i++) // bougies clôturées 1 à n
{
if(High[i] > hi) hi = High[i];
if(Low[i] < lo) lo = Low[i];
}
return true;
}
//+------------------------------------------------------------------+
//| MQL5 : une copie avec CopyRates, indexation comme en MQL4 |
//+------------------------------------------------------------------+
bool RangeMql5(const int n, double &hi, double &lo)
{
if(Bars(_Symbol, _Period) < n + 1) return false;
MqlRates rates[];
ArraySetAsSeries(rates, true); // rates[0] = bougie la plus récente copiée
// n bougies à partir de la position 1 (dernière clôturée)
if(CopyRates(_Symbol, _Period, 1, n, rates) != n)
return false; // données pas encore prêtes
hi = rates[0].high;
lo = rates[0].low;
for(int i = 1; i < n; i++)
{
if(rates[i].high > hi) hi = rates[i].high;
if(rates[i].low < lo) lo = rates[i].low;
}
return true;
}
//--- détection d'une nouvelle bougie : Time[0] devient iTime(..., 0)
bool IsNewBar()
{
static datetime last = 0;
datetime t = iTime(_Symbol, _Period, 0);
if(t == 0 || t == last) return false;
last = t;
return true;
}
Attention au décalage d’indice : dans la version MQL5, rates[0] correspond à la bougie 1 du graphique, puisque la copie commence à la position 1. Ce décalage est une source d’erreur classique. Une solution consiste à copier à partir de la position 0 et à garder exactement les mêmes indices qu’en MQL4, au prix d’une bougie supplémentaire copiée.
Les autres séries et variables
- Autre symbole ou autre période : en MQL4, il fallait déjà passer par
iClose(symbole, période, i); ce code se porte tel quel, à condition d’utiliser des constantesPERIOD_...et non des nombres de minutes. DigitsetPoint: préférez_Digitset_Point, disponibles dans les deux langages.BidetAsk: ce ne sont pas des séries mais des prix courants ; leur remplacement est traité dans MarketInfo vers SymbolInfo.IndicatorCounted(): dans les indicateurs, il est remplacé par le paramètreprev_calculateddeOnCalculate, dont la forme est la même en MQL4 moderne et en MQL5.
Les séries dans un indicateur personnalisé
Dans un indicateur, la question se pose différemment. La fonction OnCalculate de MQL5, dans sa forme complète, reçoit directement les tableaux time[], open[], high[], low[], close[], tick_volume[], volume[] et spread[] du graphique. Ce sont eux qu’il faut utiliser à la place des tableaux prédéfinis de MQL4, plutôt que des appels à iClose. Leur indexation par défaut n’est pas celle d’une série : si votre code d’origine parcourt les bougies avec l’indice 0 comme bougie la plus récente, appelez ArraySetAsSeries sur ces tableaux au début de OnCalculate, ou réécrivez la boucle dans le sens chronologique.
Les indicateurs MQL4 écrits avec la forme moderne de OnCalculate utilisent déjà ces paramètres, ce qui rend leur portage beaucoup plus simple que celui des anciens indicateurs fondés sur start() et IndicatorCounted().
Pièges fréquents
Le retour 0 ou -1 non testé
iClose renvoie 0 en cas d’erreur, et les fonctions de copie renvoient -1 ou un nombre d’éléments inférieur à celui demandé. Un code qui ne teste pas ces retours peut prendre une décision sur un prix nul. En MQL4, Close[i] au-delà de l’historique disponible posait déjà un problème comparable ; en MQL5, le risque est plus visible au démarrage, quand les données d’une autre période ne sont pas encore chargées.
Volume réel et volume en ticks
Le Volume[] de MQL4 contient un volume en ticks. En MQL5, iVolume et le champ tick_volume de MqlRates en sont l’équivalent ; le champ real_volume contient un volume réel, disponible seulement pour certains instruments boursiers. Ne mélangez pas les deux.
Les tableaux statiques
ArraySetAsSeries ne s’applique qu’aux tableaux dynamiques. Déclarez donc les tableaux de destination sans taille (double close[];), et laissez les fonctions de copie les dimensionner.
Le fonctionnement d’origine des tableaux MQL4 est rappelé dans [Tableaux de séries (Close[], Time[])](/mql4/bases/tableaux-de-series/). Pour les autres chantiers de la migration, revenez à la rubrique Migrer de MQL4 vers MQL5 ; pour les indicateurs, voyez Des fonctions iXXX aux handles.
Questions fréquentes
Par quoi remplacer Close[1] en MQL5 ?
Par iClose(_Symbol, _Period, 1), qui renvoie le prix de clôture de la dernière bougie clôturée, ou par une copie avec CopyClose ou CopyRates si vous avez besoin de plusieurs valeurs.
Quel est l’équivalent de Bars en MQL5 ?
La fonction Bars(_Symbol, _Period), ou iBars(_Symbol, _Period), qui renvoient le nombre de bougies disponibles pour le symbole et la période indiqués.
Pourquoi mes indices sont-ils inversés après CopyRates ?
Parce que les tableaux copiés sont indexés par défaut du plus ancien au plus récent. Appelez ArraySetAsSeries(tableau, true) pour que l’indice 0 désigne la bougie la plus récente copiée.
iClose est-il plus lent que Close[] ?
Chaque appel à iClose interroge la série, sans mise en cache selon la documentation de MQL5. Pour quelques valeurs par tick, la différence est négligeable ; pour de nombreuses bougies, une copie unique avec CopyRates ou CopyClose est plus efficace.
Comment lire le prix d’une bougie à une date donnée ?
Retrouvez d’abord son indice à partir de l’heure, puis lisez le prix, ou copiez directement une plage avec les variantes de CopyRates qui acceptent une date de départ. Testez toujours le nombre d’éléments copiés.
Peut-on préparer ce changement dans MQL4 ?
Oui. iClose, iTime, iHigh et les autres fonctions d’accès unitaire existent en MQL4. Remplacer les tableaux prédéfinis par ces fonctions dans le code MQL4, puis vérifier le backtest, simplifie le portage ultérieur.
