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

MQL4 · Ordres

OrderSelect en MQL4 : parcourir, filtrer et compter ses ordres

OrderSelect par position ou par ticket, boucle descendante, filtres par symbole et numéro magique : comment parcourir les ordres MQL4 sans en sauter ni toucher à ceux des autres EA.

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

OrderSelect() sélectionne un ordre pour que les fonctions OrderTicket(), OrderType(), OrderLots(), OrderOpenPrice(), OrderStopLoss(), OrderMagicNumber() et toutes les autres fonctions Order...() en renvoient les propriétés. Sa signature est bool OrderSelect(int index, int select, int pool=MODE_TRADES). Avec SELECT_BY_POS, index est une position dans la liste (de 0 à OrdersTotal() - 1 pour les ordres ouverts et en attente, ou de 0 à OrdersHistoryTotal() - 1 pour l’historique) ; avec SELECT_BY_TICKET, c’est un numéro de ticket. La fonction renvoie true si la sélection a réussi. Toute gestion d’ordres en MQL4 commence par elle.

Cette page montre comment parcourir les ordres, les filtrer correctement et écrire des fonctions de comptage et de recherche réutilisables. Elle fait partie de la rubrique Gérer les ordres en MQL4.

Les deux modes de sélection

ModeindexpoolUsage
SELECT_BY_POSPosition de 0 à total – 1MODE_TRADES (ouverts et en attente) ou MODE_HISTORY (fermés et supprimés)Parcourir tous les ordres d’une liste
SELECT_BY_TICKETNuméro de ticketIgnoréRetrouver un ordre précis, ouvert ou fermé

Avec la sélection par ticket, le paramètre pool n’est pas pris en compte : l’ordre est trouvé qu’il soit encore ouvert ou déjà dans l’historique. Pour savoir lequel, testez OrderCloseTime() : il vaut 0 tant que l’ordre est ouvert ou en attente.

Les positions dans la liste ne sont pas stables : elles changent dès qu’un ordre est ouvert, fermé ou supprimé, par votre EA, par un autre EA ou manuellement. Un indice n’identifie donc jamais un ordre dans la durée ; seul le ticket le fait.

Une copie, pas une vue en direct

OrderSelect() copie les données de l’ordre dans l’environnement du programme. Les appels suivants à OrderStopLoss(), OrderOpenPrice() ou OrderProfit() renvoient cette copie. Si l’ordre est modifié entre-temps, par exemple parce que le serveur l’a fermé sur son stop ou qu’un autre programme a changé son take profit, les valeurs lues deviennent obsolètes. La documentation recommande donc d’appeler OrderSelect() juste avant de lire les données d’un ordre. Concrètement : ne sélectionnez pas un ordre en début de fonction pour lire ses propriétés cent lignes plus loin, après des appels réseau.

Autre conséquence : la sélection est globale au programme. Si une fonction appelée au milieu de votre boucle sélectionne un autre ordre, OrderTicket() renvoie ensuite le ticket de cet autre ordre. Lisez les propriétés dont vous avez besoin dans des variables locales avant d’appeler d’autres fonctions.

La boucle de référence

#property strict

input int InpMagic = 240205;    // Numéro magique de l'EA

//+------------------------------------------------------------------+
//| Compte les ordres de l'EA sur le symbole courant, par type        |
//| type = -1 : tous les ordres (positions et en attente)             |
//+------------------------------------------------------------------+
int CompterOrdres(int type = -1)
  {
   int n = 0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;   // sélection échouée
      if(OrderSymbol() != Symbol())                   continue;   // autre symbole
      if(OrderMagicNumber() != InpMagic)              continue;   // autre EA ou manuel
      if(type >= 0 && OrderType() != type)            continue;   // autre type
      n++;
     }
   return(n);
  }

//+------------------------------------------------------------------+
//| Renvoie le ticket de la première position de l'EA, ou -1          |
//+------------------------------------------------------------------+
int TrouverPosition()
  {
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
      if(OrderSymbol() != Symbol() || OrderMagicNumber() != InpMagic) continue;
      if(OrderType() <= OP_SELL)                       // OP_BUY (0) ou OP_SELL (1)
         return(OrderTicket());
     }
   return(-1);
  }

//+------------------------------------------------------------------+
//| Profit flottant total de l'EA, swap et commission compris         |
//+------------------------------------------------------------------+
double ProfitFlottant()
  {
   double total = 0.0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
      if(OrderSymbol() != Symbol() || OrderMagicNumber() != InpMagic) continue;
      if(OrderType() > OP_SELL) continue;               // ignorer les ordres en attente
      total += OrderProfit() + OrderSwap() + OrderCommission();
     }
   return(total);
  }

void OnTick()
  {
   int achats = CompterOrdres(OP_BUY);
   int ventes = CompterOrdres(OP_SELL);
   Comment("Achats : ", achats, "  Ventes : ", ventes,
           "\nProfit flottant : ", DoubleToString(ProfitFlottant(), 2));
  }

Chaque fonction applique la même séquence : sélection, vérification du résultat, filtres, traitement. Les constantes OP_BUY (0) et OP_SELL (1) étant les deux plus petites valeurs de type, le test OrderType() <= OP_SELL isole les positions, et OrderType() > OP_SELL les ordres en attente.

Pourquoi boucler en descendant

Pour un simple comptage, le sens de la boucle n’a pas d’importance. Mais dès que la boucle ferme ou supprime des ordres, elle doit descendre. Imaginez trois ordres aux positions 0, 1 et 2. Une boucle montante ferme l’ordre 0 ; l’ancien ordre 1 passe à la position 0 et l’ancien ordre 2 à la position 1. La boucle passe à l’indice 1 et traite l’ancien ordre 2 : l’ancien ordre 1 a été sauté. En descendant, on ne touche jamais aux positions qui restent à parcourir. Prendre l’habitude de toujours descendre évite de se poser la question.

Pour la même raison, ne mettez pas OrdersTotal() en cache dans une variable avant une boucle qui ferme des ordres en montant : vous finiriez par lire des positions qui n’existent plus, et OrderSelect() renverrait false.

Les filtres indispensables

Un compte MetaTrader 4 peut contenir les ordres de plusieurs EA, sur plusieurs symboles, ainsi que des ordres passés à la main. Sans filtre, un EA prend des décisions sur des ordres qui ne sont pas les siens : il refuse d’ouvrir parce qu’il voit une position manuelle, ou ferme celle d’un autre robot. Deux filtres sont donc systématiques :

  • le symbole : OrderSymbol() == Symbol() (ou le symbole géré, pour un EA multi-paires) ;
  • le numéro magique : OrderMagicNumber() == InpMagic. Les ordres manuels ont un numéro magique égal à 0.

Le choix et la gestion du numéro magique sont détaillés dans Magic number en MQL4.

Sélection par ticket : l’usage typique

Après un OrderSend() réussi, l’EA dispose d’un ticket. Pour lire le prix réel d’exécution ou suivre cet ordre précis, on le sélectionne par ticket :

int ticket = OrderSend(Symbol(), OP_BUY, 0.10, Ask, 10, 0, 0, "", InpMagic, 0, clrNONE);
if(ticket > 0 && OrderSelect(ticket, SELECT_BY_TICKET))
  {
   if(OrderCloseTime() == 0)
      PrintFormat("Ordre %d ouvert à %s", ticket, DoubleToString(OrderOpenPrice(), Digits));
  }

Cette forme est aussi la bonne pour vérifier, après un échec de fermeture, si l’ordre a finalement été fermé par le serveur : s’il est sélectionnable et que OrderCloseTime() n’est pas nulle, il est dans l’historique.

Performance des boucles

Parcourir tous les ordres à chaque tick ne pose aucun problème sur un compte qui en contient quelques dizaines. Les fonctions OrderSelect() et Order...() lisent des données locales du terminal, sans aller-retour avec le serveur. Le coût devient en revanche sensible si chaque itération déclenche une opération de trading, ou si plusieurs fonctions de comptage parcourent la liste successivement. Dans ce dernier cas, regroupez les comptages dans une seule boucle qui remplit plusieurs variables (nombre d’achats, de ventes, d’ordres en attente, profit flottant) et appelez-la une fois par tick.

Pièges fréquents

  • Ne pas tester le retour d’OrderSelect. En cas d’échec, les fonctions Order...() renvoient les données de la sélection précédente, et la boucle travaille sur le mauvais ordre.
  • Mélanger les pools. OrdersTotal() va avec MODE_TRADES, OrdersHistoryTotal() avec MODE_HISTORY. Les croiser produit des sélections incohérentes. L’historique est traité dans Historique des ordres.
  • Oublier les ordres en attente. OrdersTotal() les inclut : filtrez le type si vous ne voulez que les positions.
  • Appeler OrderSelect dans une fonction imbriquée. La sélection courante est écrasée pour l’appelant.
  • Comparer des symboles avec suffixe : si votre courtier nomme le symbole « EURUSD.pro », un filtre écrit en dur sur « EURUSD » ne trouvera jamais d’ordre. Comparez toujours à Symbol() ou à un paramètre.
  • Supposer un ordre de tri : la documentation ne garantit pas que les positions de la liste suivent l’ordre chronologique. Pour trouver l’ordre le plus récent, comparez explicitement OrderOpenTime().

Et en MQL5 ?

MQL5 sépare les listes : PositionsTotal() et PositionGetTicket() pour les positions, OrdersTotal() et OrderGetTicket() pour les ordres en attente, HistorySelect() puis HistoryDealsTotal() ou HistoryOrdersTotal() pour l’historique. Les propriétés se lisent avec PositionGetDouble(), PositionGetInteger() et leurs équivalents. La logique de boucle descendante et de filtres reste la même. Voir Des ordres MQL4 aux positions MQL5.

FAQ

Quelle différence entre SELECT_BY_POS et SELECT_BY_TICKET ?

SELECT_BY_POS choisit l’ordre par sa position dans une liste (ouverts ou historique), SELECT_BY_TICKET par son numéro unique. La position change au fil des ouvertures et fermetures, le ticket jamais.

Pourquoi mon EA ferme-t-il les ordres d’un autre EA ?

Parce que sa boucle ne filtre pas sur le numéro magique ou sur le symbole. Ajoutez les deux conditions avant toute action.

OrdersTotal compte-t-il les ordres de tous les symboles ?

Oui, il renvoie le nombre total d’ordres ouverts et en attente du compte, tous symboles et tous programmes confondus. Le filtrage est à votre charge.

Les valeurs lues après OrderSelect sont-elles mises à jour en direct ?

Non, ce sont des copies prises au moment de la sélection. Resélectionnez l’ordre juste avant de lire une propriété susceptible d’avoir changé.

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.