Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

MQL5 · Bases du langage

ArraySetAsSeries en MQL5 : comprendre l’indexation des séries

Pourquoi tab[0] désigne tantôt la barre la plus ancienne, tantôt la barre en cours : fonctionnement d’ArraySetAsSeries, comportement des fonctions Copy et règles pour éviter les signaux inversés.

Mis à jour le 23 octobre 2026Lecture : 8 minPar Alix, OptiBot Trading

ArraySetAsSeries(tableau, true) inverse le sens d’adressage d’un tableau dynamique : l’index 0 désigne alors l’élément le plus récent (la barre en cours), l’index 1 la barre précédente, et ainsi de suite, comme dans les séries temporelles de MetaTrader. Sans cet appel, un tableau rempli par CopyClose() ou CopyRates() est indexé de gauche à droite : l’index 0 correspond à la barre la plus ancienne copiée. C’est la cause d’innombrables signaux inversés chez les développeurs qui arrivent de MQL4, où Close[0] désignait toujours la dernière barre.

Cette page fait partie de la rubrique Les bases du langage MQL5. Les tableaux en général sont présentés dans Tableaux statiques et dynamiques.

Deux sens d’indexation

La documentation officielle distingue deux conventions :

  • les tableaux ordinaires et les buffers d’indicateurs sont indexés par défaut de gauche à droite : le premier élément, d’index 0, est à l’extrême gauche ;
  • les séries temporelles ont une indexation inversée : leur premier élément est à l’extrême droite, c’est-à-dire la donnée la plus récente. Sur un graphique journalier, l’index 0 est le jour en cours, non terminé, et l’index 1 la veille.

Le point clé est que ArraySetAsSeries() ne déplace aucune donnée en mémoire. La documentation précise que la fonction modifie uniquement la manière d’adresser les éléments, pas leur stockage physique. C’est donc une opération instantanée, quelle que soit la taille du tableau.

Signature et restrictions

La signature documentée est :

bool ArraySetAsSeries(
   const void&  array[],   // tableau par reference
   bool         flag       // true = indexation inversee (serie)
   );

Elle renvoie true en cas de succès, false sinon. Deux restrictions sont explicites dans la documentation : le drapeau de série ne peut pas être appliqué à un tableau multidimensionnel, ni à un tableau statique. La fonction s’utilise donc sur des tableaux dynamiques à une dimension, ce qui correspond exactement aux tableaux de prix et de valeurs d’indicateurs.

Deux fonctions complémentaires existent : ArrayGetAsSeries() indique le sens d’indexation actuel d’un tableau, et ArrayIsSeries() indique si le tableau est une véritable série temporelle (comme les tableaux transmis à OnCalculate()). La documentation recommande de ne pas se fier aux valeurs par défaut et d’appeler explicitement ArraySetAsSeries() sur les tableaux avec lesquels on travaille.

Ce que font les fonctions de copie

Les fonctions CopyRates(), CopyClose(), CopyTime() et CopyBuffer() considèrent toujours la source comme une série : le paramètre de position 0 désigne la barre en cours, et CopyClose(_Symbol, _Period, 0, 3, tab) copie donc les trois dernières barres. La documentation précise que, quel que soit le réglage du tableau de destination, l’élément le plus ancien est stocké au début de la mémoire physique.

Autrement dit, après cet appel :

Réglage du tableautab[0]tab[2]
Par défaut (non série)la plus ancienne des trois barres copiéesla barre en cours
ArraySetAsSeries(tab, true)la barre en coursla plus ancienne des trois

Le paramètre de départ de la copie et le sens d’indexation du tableau sont deux notions indépendantes : le premier choisit quelles barres sont copiées, le second comment on les lit ensuite.

Le cas des indicateurs

Dans un indicateur, les tableaux reçus par OnCalculate() (time[], open[], close[]…) et les buffers déclarés avec SetIndexBuffer() sont, par défaut, indexés de gauche à droite. C’est cohérent avec le calcul incrémental à partir de prev_calculated : on boucle de la plus ancienne barre non calculée vers la plus récente, avec un index croissant. Si vous préférez raisonner en mode série, appliquez ArraySetAsSeries() à tous les tableaux utilisés, buffers compris, et adaptez la boucle. Mélanger les deux conventions dans un même calcul est l’erreur la plus fréquente. Le mécanisme de prev_calculated est détaillé dans OnCalculate et prev_calculated.

Effet sur les autres fonctions de tableau

Le drapeau de série n’est pas pris en compte de la même manière par toutes les fonctions :

  • ArrayMaximum() et ArrayMinimum() en tiennent compte : l’index renvoyé correspond au sens d’adressage du tableau ;
  • ArraySort() trie toujours par ordre croissant, quel que soit le drapeau, selon la documentation ;
  • ArrayCopy() ajuste correctement la position de départ pour les tableaux en série, et un tableau de destination dynamique en série s’agrandit si nécessaire.

Exemple complet : vérifier le sens d’indexation

Ce script copie les mêmes barres dans deux tableaux, l’un laissé par défaut, l’autre passé en série, et affiche ce que contient l’index 0 de chacun.

//+------------------------------------------------------------------+
//| Script : effet de ArraySetAsSeries sur un tableau de prix        |
//+------------------------------------------------------------------+
void OnStart()
  {
   double   closeDefaut[], closeSerie[];
   datetime heures[];

   // Le tableau des heures et closeSerie sont passes en serie : index 0 = barre courante
   ArraySetAsSeries(closeSerie, true);
   ArraySetAsSeries(heures, true);

   int n1 = CopyClose(_Symbol, _Period, 0, 5, closeDefaut);  // 5 dernieres barres
   int n2 = CopyClose(_Symbol, _Period, 0, 5, closeSerie);
   int n3 = CopyTime(_Symbol, _Period, 0, 5, heures);
   if(n1 != 5 || n2 != 5 || n3 != 5)
     {
      Print("Copie incomplete, erreur ", GetLastError());
      return;
     }

   PrintFormat("Serie ? defaut=%s, serie=%s",
               ArrayGetAsSeries(closeDefaut) ? "oui" : "non",
               ArrayGetAsSeries(closeSerie)  ? "oui" : "non");

   for(int i = 0; i < 5; i++)
     {
      // closeDefaut[i] et closeSerie[4 - i] designent la meme barre
      PrintFormat("i=%d | defaut %.*f | serie %.*f (barre de %s)",
                  i, _Digits, closeDefaut[i], _Digits, closeSerie[i],
                  TimeToString(heures[i]));
     }

   // Exemple de signal : cloture de la derniere barre terminee au-dessus de la precedente
   bool hausse = (closeSerie[1] > closeSerie[2]);   // lisible grace a l'indexation serie
   PrintFormat("Derniere barre terminee haussiere : %s", hausse ? "oui" : "non");
  }

En exécutant ce script sur n’importe quel graphique, vous verrez que closeDefaut[0] est égal à closeSerie[4] : il s’agit de la même barre, la plus ancienne des cinq. Le tableau heures, également en série, permet de vérifier à quelle barre correspond chaque index de closeSerie.

Diagnostiquer un problème d’indexation

Un EA qui achète systématiquement au mauvais moment, ou dont le signal semble décalé de plusieurs dizaines de barres, souffre souvent d’une indexation inversée. Pour le vérifier, copiez en même temps les heures d’ouverture avec CopyTime() dans un tableau réglé de la même façon que vos prix, puis affichez dans le journal l’heure associée aux index 0, 1 et au dernier index. Si l’index 0 affiche une date ancienne, le tableau n’est pas en série. Ce contrôle prend deux lignes de code et lève le doute immédiatement. En backtest, le mode visuel permet ensuite de comparer la barre signalée dans le journal avec celle du graphique.

Un autre symptôme typique est un croisement de moyennes détecté avec un retard égal au nombre de barres copiées : l’EA compare en réalité les deux valeurs les plus anciennes du tableau au lieu des deux plus récentes.

Bonnes pratiques dans un Expert Advisor

  • Décidez d’une convention unique pour tout l’EA. La plupart des développeurs choisissent le mode série, qui correspond à la lecture naturelle d’un graphique : 0 pour la barre en cours, 1 pour la dernière barre close.
  • Appelez ArraySetAsSeries() une fois, juste après la déclaration du tableau ou dans OnInit() pour un tableau global. Le réglage reste valable pour les copies suivantes.
  • Travaillez sur les barres closes : l’index 0 en mode série est la barre en formation, dont la clôture change à chaque tick. Un signal calculé sur l’index 0 peut apparaître puis disparaître dans la même bougie. Basez les décisions sur l’index 1 et suivants, comme expliqué dans Coder un signal d’entrée.
  • Documentez le sens dans un commentaire à côté de la déclaration : le lecteur suivant (vous dans six mois) vous en remerciera.
  • Ne supposez rien sur OnCalculate() : fixez explicitement le sens des tableaux reçus avant de les utiliser.

Pour les développeurs qui migrent un code MQL4 où Close[i] et Time[i] étaient des séries par construction, la page Remplacer les tableaux Close et Time de MQL4 détaille les équivalences.

FAQ

Pourquoi tab[0] contient-il la barre la plus ancienne après CopyClose ?

Parce qu’un tableau dynamique est indexé de gauche à droite par défaut et que les fonctions de copie stockent l’élément le plus ancien au début de la mémoire. Appelez ArraySetAsSeries(tab, true) pour que tab[0] désigne la barre en cours.

ArraySetAsSeries déplace-t-il les données en mémoire ?

Non. La documentation précise que seul le mode d’adressage change ; le stockage physique reste identique. L’opération est donc instantanée.

Peut-on utiliser ArraySetAsSeries sur un tableau statique ?

Non. Le drapeau de série ne peut pas être appliqué aux tableaux statiques ni aux tableaux multidimensionnels. Déclarez un tableau dynamique à une dimension.

Faut-il rappeler ArraySetAsSeries avant chaque CopyBuffer ?

Non, le réglage reste attaché au tableau. Un appel unique après la déclaration suffit, tant que vous ne le modifiez pas ensuite.

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.