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.
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
| Situation | Boucle conseillée |
|---|---|
| Parcourir N barres ou un tableau de taille connue | for croissant |
| Fermer, modifier ou supprimer des positions ou des ordres | for décroissant |
| Répéter jusqu’à ce qu’une condition change | while avec limite d’itérations |
| Exécuter une tentative puis vérifier le résultat | do while |
| Boucle de service dans un script qui tourne en continu | while(!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 boucleswhile. - 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 esti < 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++)rappelleArraySize()à 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.
- Types de données en MQL5
- Variables, constantes et portée
- Paramètres input et sinput
- Opérateurs et expressions
- Conditions if, else et switch
- Écrire ses propres fonctions
- Tableaux statiques et dynamiques
- ArraySetAsSeries et indexation des séries
- Manipuler les chaînes de caractères
- Dates, heures et fuseaux
- Structures (struct) et MqlRates, MqlTick
- Énumérations (enum) personnalisées
- #include, #define et #property
- Les fonctions événementielles
- Print, Comment, Alert : déboguer avec le journal
- NormalizeDouble et précision des prix
- SymbolInfoDouble, SymbolInfoInteger
- AccountInfoDouble : lire les informations du compte
- Bien utiliser MetaEditor
