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

ProRealTime · ProBuilder

Boucles en ProBuilder : FOR, WHILE, BREAK et CONTINUE

Syntaxe de FOR TO/DOWNTO et WHILE WEND, sorties avec BREAK et CONTINUE, et surtout savoir quand une boucle est utile en ProBuilder et comment éviter les boucles infinies.

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

ProBuilder propose deux boucles : FOR variable = début TO fin DO ... NEXT, qui répète un bloc un nombre de fois connu (ou DOWNTO pour compter à rebours), et WHILE condition DO ... WEND, qui répète tant qu’une condition reste vraie. BREAK permet de sortir immédiatement d’une boucle et CONTINUE de passer à l’itération suivante. Ces boucles s’exécutent à l’intérieur d’une barre : elles servent à examiner les barres passées ou un tableau, pas à parcourir le graphique, ce que le moteur fait déjà pour vous.

Cette page explique la syntaxe de chaque boucle, montre quand elles sont réellement utiles et comment éviter les deux grands écueils : la boucle infinie et la boucle inutile qui ralentit tout le graphique. Elle fait partie de la rubrique Le langage ProBuilder.

Avant d’écrire une boucle : en avez-vous besoin ?

Rappel essentiel : votre programme est déjà exécuté une fois par barre. Pour calculer une moyenne, une somme ou un extrême sur les N dernières barres, ProBuilder fournit des fonctions optimisées : Average[n](x), Summation[n](x), Highest[n](x), Lowest[n](x). Les réécrire avec une boucle FOR donne le même résultat, en beaucoup plus lent, puisque la boucle est relancée sur chaque barre de l’historique.

Une boucle se justifie quand le nombre de barres à examiner dépend des données (compter une série de bougies consécutives, chercher la dernière barre qui remplit une condition), quand on parcourt un tableau $, ou quand on dessine plusieurs objets graphiques à partir d’un même point. Les fonctions d’extremum sont décrites sur la page Highest et Lowest.

La boucle FOR

Syntaxe ascendante : TO

FOR i = 1 TO 10 DO
   // instructions répétées avec i = 1, 2, ..., 10
NEXT

La variable de boucle prend successivement toutes les valeurs entières de la borne de départ à la borne d’arrivée, incluses. Les bornes peuvent être des variables ou des expressions. Il n’existe pas de pas personnalisé : la variable avance de 1 à chaque tour.

Syntaxe descendante : DOWNTO

FOR i = 10 DOWNTO 1 DO
   // instructions répétées avec i = 10, 9, ..., 1
NEXT

DOWNTO parcourt les valeurs en sens inverse. C’est utile, par exemple, pour traiter les barres de la plus ancienne à la plus récente quand l’indice 0 désigne la barre courante.

Exemple : somme pondérée manuelle

La documentation officielle illustre FOR en additionnant plusieurs moyennes mobiles de périodes différentes. Voici une variante qui combine trois périodes consécutives, un calcul qu’aucune fonction prédéfinie ne fait directement :

total = 0                              // accumulateur initialisé à chaque barre
FOR p = 11 TO 13 DO
   total = total + Average[p](Close)   // moyennes 11, 12 et 13 périodes
NEXT
moyenneDesMoyennes = total / 3
RETURN moyenneDesMoyennes

L’initialisation total = 0 avant la boucle est indispensable : sans elle, l’accumulateur repartirait de sa valeur de la barre précédente.

La boucle WHILE

WHILE condition DO
   // instructions répétées tant que la condition est vraie
WEND

La condition est vérifiée avant chaque passage. Si elle est fausse dès le départ, le corps de la boucle n’est jamais exécuté. Il vous appartient de garantir qu’elle finira par devenir fausse ; sinon la boucle ne s’arrête pas, ce que la documentation qualifie de risque de blocage du programme.

Exemple : compter les clôtures en hausse consécutives

hausse = Close > Close[1]              // 1 si la barre clôture en hausse
compte = 0
WHILE hausse[compte] AND compte < 50 DO   // borne de sécurité à 50 barres
   compte = compte + 1
WEND
RETURN compte AS "Hausses consécutives"

La boucle remonte dans l’historique de hausse tant que les barres sont haussières. La borne compte < 50 est une sécurité : elle garantit la sortie de boucle et évite de lire au-delà de l’historique disponible.

BREAK et CONTINUE

BREAK force la sortie immédiate d’une boucle FOR ou WHILE. Il s’utilise presque toujours dans un IF. Selon la documentation, l’utiliser hors d’une boucle provoque une erreur.

CONTINUE termine l’itération en cours et passe directement à la suivante, sans exécuter les instructions restantes du corps.

// Nombre de barres consécutives où le volume progresse (20 barres maximum)
indicateur = 0
FOR i = 0 TO 19 DO
   IF Volume[i] > Volume[i + 1] THEN
      indicateur = indicateur + 1      // le volume progresse encore
   ELSE
      BREAK                            // première rupture : on arrête de compter
   ENDIF
NEXT
RETURN indicateur

Sans BREAK, la boucle compterait toutes les barres où le volume progresse sur les vingt dernières, consécutives ou non : le résultat ne mesurerait plus la même chose.

FOR ou WHILE : comment choisir

La règle pratique est simple. Utilisez FOR dès que vous connaissez le nombre maximal d’itérations : la boucle se termine forcément, et la variable de boucle sert directement d’indice (Close[i], $tableau[i]). Utilisez WHILE lorsque l’arrêt dépend uniquement d’une condition sur les données, par exemple « tant que les bougies sont haussières ». Dans ce second cas, ajoutez toujours une borne de sécurité. En pratique, une boucle FOR combinée à BREAK couvre la plupart des besoins et présente moins de risques qu’un WHILE : la borne de fin joue le rôle de garde-fou, et BREAK assure la sortie anticipée dès que la condition recherchée est remplie. C’est la forme à privilégier si vous débutez.

Exemple complet : distance au dernier plus haut significatif

Cet indicateur recherche, parmi les 100 dernières barres, la plus récente dont le plus haut dépasse de plus d’un ATR la clôture actuelle, et renvoie le nombre de barres écoulées. C’est un calcul typique où la boucle est justifiée : on s’arrête dès que la barre recherchée est trouvée.

// Nombre de barres depuis le dernier plus haut situé à plus d'un ATR au-dessus du prix
DEFPARAM CALCULATEONLASTBARS = 2000    // limite la charge de calcul
profondeur = 100                       // nombre maximal de barres examinées
atr = AverageTrueRange[14](Close)

distance = 0                           // 0 = aucune barre trouvée
IF BarIndex > profondeur THEN          // assez d'historique pour la recherche
   FOR i = 1 TO profondeur DO
      IF High[i] > Close + atr THEN
         distance = i                  // barre trouvée
         BREAK                         // inutile de chercher plus loin
      ENDIF
   NEXT
ENDIF

RETURN distance AS "Barres depuis un sommet > 1 ATR"

Le DEFPARAM CALCULATEONLASTBARS placé en tête de code limite le calcul aux barres récentes : une boucle de 100 itérations exécutée sur des dizaines de milliers de barres peut sinon rendre l’affichage sensiblement plus lent.

Le sens de parcours des barres

Dans une boucle, l’indice 0 désigne toujours la barre courante, 1 la précédente, et ainsi de suite vers le passé. Une boucle FOR i = 0 TO 19 part donc de la barre actuelle et remonte dans l’historique : c’est le sens naturel pour rechercher l’événement le plus récent et s’arrêter dès qu’il est trouvé. À l’inverse, FOR i = 19 DOWNTO 0 commence par la barre la plus ancienne de la fenêtre et revient vers la barre courante, ce qui convient lorsqu’on veut reproduire un calcul chronologique, par exemple un lissage qui dépend de la valeur précédente. Se tromper de sens ne provoque aucune erreur de validation, mais donne un résultat différent : vérifiez toujours, sur quelques barres, que la valeur affichée correspond à ce que vous attendez.

Les pièges à éviter

  • Boucle infinie : une condition WHILE qui ne devient jamais fausse. Ajoutez systématiquement un compteur et une borne maximale.
  • Accumulateur non initialisé : sans remise à zéro avant la boucle, la somme se cumule d’une barre à l’autre. La documentation signale aussi qu’une condition inconnue est traitée comme 0, ce qui peut fausser une boucle dont la variable n’est pas initialisée.
  • Lecture hors historique : Close[i] avec un i supérieur au nombre de barres disponibles. Filtrez les premières barres avec BarIndex.
  • Boucles imbriquées coûteuses : deux boucles de 100 itérations font 10 000 opérations par barre. Réservez-les aux calculs sur les dernières barres.
  • Boucle qui remplace une fonction native : préférez Summation, Highest ou Average dès qu’ils conviennent.

Les boucles servent aussi beaucoup avec les tableaux, qui se parcourent par indice : voir le guide Tableaux ($tableau). Pour diagnostiquer un code qui se bloque, consultez les erreurs fréquentes en ProBuilder.

FAQ

Peut-on choisir le pas d’une boucle FOR ?

Non, la variable avance de 1 avec TO ou recule de 1 avec DOWNTO. Pour un pas de 2, multipliez la variable dans le corps de la boucle (utilisez Close[i * 2]) ou testez i MOD 2 = 0 avec CONTINUE pour sauter une itération sur deux.

Comment sortir d’une boucle avant la fin ?

Avec BREAK, généralement placé dans un IF. La boucle s’arrête immédiatement et l’exécution reprend après NEXT ou WEND.

Pourquoi mon indicateur devient-il très lent avec une boucle ?

Parce que la boucle est exécutée sur chaque barre de l’historique. Réduisez le nombre d’itérations, sortez dès que possible avec BREAK, remplacez la boucle par une fonction native quand elle existe, ou limitez le calcul avec DEFPARAM CALCULATEONLASTBARS.

Une boucle permet-elle de parcourir toutes les barres du graphique ?

Ce n’est pas nécessaire : le moteur exécute déjà votre code sur chaque barre. Une boucle sert à examiner, depuis la barre courante, un certain nombre de barres passées ou les éléments d’un tableau.

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.