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

MQL5 · Bases du langage

Boucles en MQL5 : for, while, do while, break et continue

Répéter un traitement sur des barres, des tableaux ou des positions : syntaxe des trois boucles MQL5, break et continue, parcours à rebours des positions et protections contre les boucles infinies.

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

MQL5 propose trois boucles héritées du C : for quand le nombre d’itérations est connu (parcourir 100 barres, toutes les positions ouvertes), while quand on répète tant qu’une condition reste vraie, et do while quand le corps doit s’exécuter au moins une fois. break sort immédiatement de la boucle, continue passe à l’itération suivante. Dans un Expert Advisor, la boucle la plus importante est le parcours des positions ou des ordres, qui se fait à rebours dès que la boucle peut fermer ou supprimer des éléments.

Cette page fait partie de la rubrique Les bases du langage MQL5.

La boucle for

La syntaxe est for(expression1; expression2; expression3) instruction;. La première expression initialise le compteur, la deuxième est la condition testée avant chaque passage, la troisième s’exécute après chaque passage. La documentation précise que chacune des trois expressions peut être omise, à condition de conserver les points-virgules ; une condition absente est considérée comme toujours vraie, si bien que for(;;) est une boucle infinie équivalente à while(1). Les expressions 1 et 3 peuvent contenir plusieurs instructions séparées par des virgules, par exemple for(int i = 0, j = n - 1; i < j; i++, j--).

Le compteur déclaré dans l’en-tête (for(int i = 0; ...)) n’existe que dans la boucle. Si vous avez besoin de sa valeur finale après la boucle, déclarez-le avant.

Usage typique : parcourir un tableau de prix copié avec CopyClose(), calculer une moyenne ou chercher un plus haut sur N barres.

La boucle while

while(expression) instruction; teste la condition avant chaque passage. Si elle est fausse dès le départ, le corps n’est jamais exécuté. C’est la boucle adaptée aux répétitions dont on ne connaît pas le nombre à l’avance : attendre qu’une donnée soit disponible, relire un fichier ligne par ligne jusqu’à sa fin, réduire un lot jusqu’à ce qu’il respecte une contrainte de marge.

La boucle do while

do instruction; while(expression); exécute le corps d’abord, puis teste la condition. Le corps passe donc au moins une fois. Cette forme est utile lorsque la condition dépend d’un calcul effectué dans la boucle, par exemple une tentative d’opération suivie d’un test de réussite.

break et continue

break interrompt la boucle la plus proche et reprend l’exécution après elle. On l’utilise pour arrêter une recherche dès que l’élément est trouvé, ou pour sortir d’une boucle infinie contrôlée. continue saute la fin du corps et passe directement à l’itération suivante (pour un for, l’expression 3 est exécutée avant le nouveau test). On l’utilise pour ignorer les éléments qui ne nous concernent pas, typiquement les positions d’un autre symbole ou d’un autre magic number.

Dans des boucles imbriquées, break ne sort que de la boucle intérieure. Pour sortir de toutes les boucles, utilisez un drapeau booléen testé dans la condition de la boucle extérieure, ou placez les boucles dans une fonction et sortez avec return.

Boucles longues et IsStopped()

Une boucle qui tourne longtemps empêche le programme de répondre aux autres événements et à une demande d’arrêt. La documentation de do while recommande, lorsqu’un grand nombre d’itérations est attendu, de vérifier IsStopped() dans la condition. Cette fonction renvoie true quand le terminal a demandé l’arrêt du programme ; la documentation précise qu’un programme qui ignore cette demande est arrêté de force au bout de 3 secondes. L’écriture type est while(condition && !IsStopped()).

Dans OnTick(), gardez en tête que les ticks qui arrivent pendant l’exécution du gestionnaire ne sont pas mis en file : une boucle lente fait donc manquer des cotations. Une boucle de quelques centaines d’itérations ne pose aucun problème ; une boucle sur tout l’historique à chaque tick en pose un.

Parcourir les positions : pourquoi à rebours

Les positions ouvertes sont indexées de 0 à PositionsTotal() - 1. Si une boucle croissante ferme la position d’index 0, toutes les suivantes se décalent : l’ancienne position 1 devient la position 0, et la boucle, qui passe à l’index 1, la saute. Parcourir de PositionsTotal() - 1 jusqu’à 0 évite ce décalage, puisque les fermetures n’affectent que des index déjà traités. La même règle vaut pour les ordres en attente avec OrdersTotal().

Le parcours et le filtrage des positions sont détaillés dans Parcourir et filtrer les positions, et la fermeture elle-même dans Fermer une position.

Exemple complet : trois boucles dans un même script

//+------------------------------------------------------------------+
//| Script : for, while, do while, break et continue                 |
//+------------------------------------------------------------------+
#property script_show_inputs

input int   InpNbBarres = 50;      // Nombre de barres analysees
input ulong InpMagic    = 240501;  // Magic number a filtrer

void OnStart()
  {
   //--- 1. for : plus haut des N dernieres cloture
   double closes[];
   ArraySetAsSeries(closes, true);                       // index 0 = barre courante
   int copies = CopyClose(_Symbol, _Period, 0, InpNbBarres, closes);
   if(copies <= 0)
     {
      Print("CopyClose a echoue, erreur ", GetLastError());
      return;
     }
   double plusHaut = closes[0];
   int    indexHaut = 0;
   for(int i = 1; i < copies; i++)
     {
      if(closes[i] > plusHaut)
        {
         plusHaut  = closes[i];
         indexHaut = i;
        }
     }
   PrintFormat("Plus haute cloture : %.*f, il y a %d barres", _Digits, plusHaut, indexHaut);

   //--- 2. for a rebours avec continue : positions de cet EA sur ce symbole
   int compte = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      ulong ticket = PositionGetTicket(i);               // selectionne la position
      if(ticket == 0)
         continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol)
         continue;                                       // autre symbole : on ignore
      if((ulong)PositionGetInteger(POSITION_MAGIC) != InpMagic)
         continue;                                       // autre EA : on ignore
      compte++;
     }
   PrintFormat("Positions de cet EA sur %s : %d", _Symbol, compte);

   //--- 3. while avec break et IsStopped : premiere barre baissiere
   int k = 0;
   while(k < copies - 1 && !IsStopped())
     {
      if(closes[k] < closes[k + 1])
        {
         PrintFormat("Derniere barre baissiere : index %d", k);
         break;                                          // trouve : on sort
        }
      k++;
     }

   //--- 4. do while : division d'un lot jusqu'au minimum autorise
   double lotMin = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double lot    = 1.0;
   int    etapes = 0;
   do
     {
      lot /= 2.0;
      etapes++;
     }
   while(lot / 2.0 >= lotMin && etapes < 20);            // garde-fou contre une boucle infinie
   PrintFormat("Lot apres %d divisions : %.4f (minimum %.2f)", etapes, lot, lotMin);
  }

Les quatre blocs illustrent chacun un usage typique. Le premier parcourt un tableau en série avec un compteur croissant, le deuxième filtre les positions à rebours avec continue, le troisième cherche un élément et s’arrête dès qu’il est trouvé, le quatrième répète un calcul au moins une fois avec un garde-fou sur le nombre d’étapes.

Choisir la bonne boucle

SituationBoucle conseillée
Parcourir N barres ou un tableau de taille connuefor croissant
Fermer, modifier ou supprimer des positions ou des ordresfor décroissant
Répéter jusqu’à ce qu’une condition changewhile avec limite d’itérations
Exécuter une tentative puis vérifier le résultatdo while
Boucle de service dans un script qui tourne en continuwhile(!IsStopped())

En cas d’hésitation, préférez for : son en-tête regroupe l’initialisation, la condition et la progression, ce qui rend les boucles infinies accidentelles beaucoup plus rares. Réservez while aux cas où la condition d’arrêt ne dépend pas d’un simple compteur.

Pièges fréquents

  • Boucle infinie : un compteur jamais incrémenté, ou une condition qui ne peut pas devenir fausse, bloque le programme. Ajoutez systématiquement une limite d’itérations ou un test IsStopped() aux boucles while.
  • Dépassement de tableau : for(int i = 0; i <= ArraySize(tab); i++) lit un élément de trop et déclenche l’erreur critique « array out of range ». La condition correcte est i < ArraySize(tab). Voir Array out of range.
  • Boucle croissante qui ferme des positions : des positions sont sautées. Parcourez à rebours.
  • Appel coûteux dans la condition : for(int i = 0; i < ArraySize(tab); i++) rappelle ArraySize() à chaque tour. Sur un petit tableau c’est négligeable, mais stocker la taille dans une variable avant la boucle est une bonne habitude.
  • Point-virgule après l’en-tête : for(int i = 0; i < n; i++); exécute une boucle vide, puis le bloc suivant une seule fois.
  • Indexation inversée oubliée : si un tableau n’a pas été passé en série, l’index 0 correspond à la barre la plus ancienne. Vérifiez le sens avant de boucler ; le sujet est traité dans ArraySetAsSeries et indexation des séries.

FAQ

Pourquoi parcourir les positions de la fin vers le début ?

Parce que fermer une position décale les index de toutes les suivantes. Une boucle croissante saute alors des positions. En partant de PositionsTotal() – 1 et en descendant jusqu’à 0, chaque fermeture n’affecte que des index déjà traités.

Quelle différence entre while et do while ?

while teste la condition avant chaque passage : le corps peut ne jamais être exécuté. do while teste après : le corps est exécuté au moins une fois.

Comment sortir de deux boucles imbriquées ?

break ne sort que de la boucle la plus proche. Utilisez un drapeau booléen vérifié par la boucle extérieure, ou placez les deux boucles dans une fonction et sortez avec return.

Une boucle dans OnTick peut-elle faire manquer des ticks ?

Oui. Tant que OnTick s’exécute, les nouveaux ticks du symbole ne sont pas mis en file d’attente. Une boucle très longue retarde donc la réaction de l’EA. Limitez le travail effectué à chaque tick, par exemple en ne recalculant qu’à l’ouverture d’une nouvelle bougie.

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.