MQL5 · Ordres et positions
Parcourir et filtrer les positions en MQL5 : PositionsTotal, PositionGetTicket et filtres
Compter ses positions, calculer son exposition, ne toucher qu’aux trades de son EA : la boucle de parcours des positions et des ordres en MQL5, ses filtres et ses pièges.
Pour parcourir les positions ouvertes en MQL5, bouclez de PositionsTotal() - 1 jusqu’à 0, récupérez chaque ticket avec PositionGetTicket(i), qui sélectionne automatiquement la position, puis lisez ses propriétés avec PositionGetString(POSITION_SYMBOL), PositionGetInteger(POSITION_MAGIC) ou PositionGetInteger(POSITION_TYPE) pour ne garder que celles de votre Expert Advisor. Les ordres en attente se parcourent de la même façon avec OrdersTotal() et OrderGetTicket(i).
Cette boucle est le bloc de base de presque toutes les fonctions de gestion : compter ses positions, calculer son exposition, appliquer un trailing stop, tout fermer. Cette page fait partie de la rubrique Ordres et positions en MQL5.
Les fonctions de base
| Fonction | Rôle |
|---|---|
int PositionsTotal() | nombre de positions ouvertes sur le compte |
ulong PositionGetTicket(int index) | ticket de la position d’index donné, qui est sélectionnée ; 0 en cas d’échec |
string PositionGetSymbol(int index) | symbole de la position d’index donné, qui est sélectionnée ; chaîne vide en cas d’échec |
bool PositionSelect(string symbol) | sélectionne la position du symbole (en hedging : celle au ticket le plus bas) |
bool PositionSelectByTicket(ulong ticket) | sélectionne une position par son ticket |
PositionGetInteger, PositionGetDouble, PositionGetString | lisent les propriétés de la position sélectionnée |
La documentation précise que PositionGetTicket sélectionne automatiquement la position pour les appels suivants à PositionGetDouble, PositionGetInteger et PositionGetString. Elle avertit aussi que la sélection copie les données dans l’environnement du programme : si la position change ensuite, les valeurs lues peuvent être périmées. Lisez donc les propriétés immédiatement après la sélection, dans la même itération.
Les propriétés utiles pour filtrer
POSITION_SYMBOL(chaîne) : le symbole ;POSITION_MAGIC(entier) : le magic number de l’ordre qui a ouvert la position ;POSITION_TYPE:POSITION_TYPE_BUYouPOSITION_TYPE_SELL;POSITION_VOLUME,POSITION_PRICE_OPEN,POSITION_SL,POSITION_TP,POSITION_PROFIT,POSITION_SWAP(doubles) ;POSITION_TIME: l’heure d’ouverture ;POSITION_IDENTIFIER: l’identifiant qui relie la position à ses ordres et deals ;POSITION_COMMENT: le commentaire.
Le filtre minimal d’un EA combine symbole et magic number. Sans filtre de symbole, un EA placé sur plusieurs graphiques avec le même magic number agirait sur les positions des autres graphiques. Sans filtre de magic number, il agirait sur les positions manuelles ou celles d’autres EA. Le choix des valeurs est discuté dans la page Le magic number.
Pourquoi boucler à l’envers
Quand une boucle ferme des positions, chaque fermeture retire un élément de la liste. Avec une boucle croissante, la position suivante prend l’index de celle qui vient d’être fermée, et l’incrément de la boucle la fait sauter. Avec une boucle décroissante, les positions restantes d’index inférieur ne bougent pas.
Même pour une boucle qui ne ferme rien, prendre l’habitude de l’ordre décroissant évite une classe entière de bugs quand le code évolue. Gardez aussi à l’esprit que la liste peut changer pendant la boucle sans action de votre part : un stop loss peut être touché entre deux itérations. Testez donc systématiquement le retour de PositionGetTicket (0 en cas d’échec).
Exemple : une boîte à outils de comptage et d’exposition
Les fonctions ci-dessous couvrent les besoins courants : compter les positions de l’EA par sens, calculer le volume net et le profit flottant, et trouver la position la plus ancienne.
//+------------------------------------------------------------------+
//| Outils de parcours et de filtrage des positions |
//+------------------------------------------------------------------+
input ulong InpMagic = 240512;
//--- true si la position sélectionnée appartient à l'EA sur ce symbole
bool IsMine(const string symbol)
{
return(PositionGetString(POSITION_SYMBOL) == symbol &&
(ulong)PositionGetInteger(POSITION_MAGIC) == InpMagic);
}
//--- nombre de positions de l'EA dans un sens (ou les deux si type < 0)
int CountMine(const string symbol, int type = -1)
{
int n = 0;
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
if(PositionGetTicket(i) == 0) continue; // sélection
if(!IsMine(symbol)) continue;
if(type >= 0 && PositionGetInteger(POSITION_TYPE) != type) continue;
n++;
}
return(n);
}
//--- volume net (achats - ventes) et profit flottant des positions de l'EA
void Exposure(const string symbol, double &net_volume, double &floating)
{
net_volume = 0.0;
floating = 0.0;
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
if(PositionGetTicket(i) == 0) continue;
if(!IsMine(symbol)) continue;
double v = PositionGetDouble(POSITION_VOLUME);
net_volume += (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) ? v : -v;
floating += PositionGetDouble(POSITION_PROFIT) + PositionGetDouble(POSITION_SWAP);
}
}
//--- ticket de la position la plus ancienne de l'EA (0 si aucune)
ulong OldestMine(const string symbol)
{
ulong best = 0;
datetime t0 = 0;
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong ticket = PositionGetTicket(i);
if(ticket == 0 || !IsMine(symbol)) continue;
datetime t = (datetime)PositionGetInteger(POSITION_TIME);
if(best == 0 || t < t0) { best = ticket; t0 = t; }
}
return(best);
}
//--- même logique pour les ordres en attente
int CountMyPendingOrders(const string symbol)
{
int n = 0;
for(int i = OrdersTotal() - 1; i >= 0; i--)
{
ulong ticket = OrderGetTicket(i); // sélectionne l'ordre
if(ticket == 0) continue;
if(OrderGetString(ORDER_SYMBOL) == symbol &&
(ulong)OrderGetInteger(ORDER_MAGIC) == InpMagic)
n++;
}
return(n);
}
void OnTick()
{
double net, pnl;
Exposure(_Symbol, net, pnl);
Comment(StringFormat("Positions EA : %d (achats %d, ventes %d)\nVolume net : %.2f\nFlottant : %.2f",
CountMine(_Symbol), CountMine(_Symbol, POSITION_TYPE_BUY),
CountMine(_Symbol, POSITION_TYPE_SELL), net, pnl));
}
La fonction OldestMine est utile sur les comptes soumis à la règle FIFO, où la position la plus ancienne doit être fermée en premier, comme expliqué dans Fermer une position. Le profit flottant calculé ici ajoute le swap mais pas les commissions, qui sont enregistrées sur les deals ; pour un résultat complet, consultez l’historique.
L’alternative orientée objet : CPositionInfo
La bibliothèque standard propose la classe CPositionInfo (#include <Trade\PositionInfo.mqh>). Sa méthode SelectByIndex(index) remplace PositionGetTicket, et des méthodes comme Symbol(), Magic(), PositionType(), Volume(), PriceOpen(), StopLoss(), TakeProfit(), Profit() ou Swap() remplacent les appels PositionGet…. Le résultat est plus lisible mais strictement équivalent : la sélection et ses limites (données copiées, à relire juste avant usage) restent les mêmes. La classe propose aussi SelectByTicket et SelectByMagic.
Netting, hedging et parcours
Sur un compte netting, il y a au plus une position par symbole : PositionSelect(symbol) suffit pour la trouver, et la boucle ne sert que pour un EA multi-symboles. Sur un compte hedging, plusieurs positions coexistent et la boucle avec filtre est la seule méthode fiable. Écrire systématiquement la boucle rend le code valable dans les deux cas ; les différences sont détaillées dans Comptes netting ou hedging.
Faut-il mémoriser les positions plutôt que les parcourir ?
Une tentation fréquente consiste à stocker les tickets des positions ouvertes dans un tableau global, mis à jour à chaque ouverture et fermeture, pour éviter de parcourir la liste. C’est rarement une bonne idée. La liste du terminal reste la seule source fiable : une position peut être fermée par son stop, par le broker lors d’un stop out, ou à la main, sans que votre EA en soit informé au moment où il consulte son tableau. Après un redémarrage du terminal, le tableau est vide alors que les positions existent toujours.
Parcourir quelques positions à chaque tick ne pose aucun problème de performance. Si vous avez besoin d’un état propre à l’EA (par exemple le stop initial d’une position), associez-le au ticket mais revérifiez toujours l’existence de la position dans la liste avant de l’utiliser. Pour réagir immédiatement à une fermeture sans attendre le tick suivant, l’événement OnTradeTransaction est l’outil adapté.
Cas d’usage et pièges
Limiter le nombre de positions. Avant chaque entrée, CountMine permet de refuser une nouvelle position si l’EA en a déjà le nombre maximal autorisé. C’est le garde-fou le plus simple contre les ouvertures répétées à chaque tick.
Contrôler l’exposition globale. Un EA multi-symboles peut additionner les volumes ou les risques de toutes ses positions pour respecter une limite globale, en retirant le filtre de symbole et en conservant le filtre de magic number. La gestion de plusieurs symboles est traitée dans EA multi-symboles.
Confondre positions et ordres. PositionsTotal ne compte pas les ordres en attente, et OrdersTotal ne compte pas les positions. Un EA qui gère les deux doit faire deux boucles.
Relire après modification. Après un PositionModify dans la boucle, les valeurs déjà lues pour cette position ne sont plus à jour. Si vous en avez besoin, resélectionnez la position par son ticket.
FAQ
Faut-il appeler PositionSelect avant PositionGetInteger dans une boucle ?
Non : PositionGetTicket(i) sélectionne déjà la position d’index i. Lisez ses propriétés juste après, dans la même itération.
Pourquoi ma boucle de fermeture laisse-t-elle des positions ouvertes ?
Probablement parce qu’elle est croissante : chaque fermeture décale les index et la boucle saute une position sur deux. Parcourez la liste de PositionsTotal() - 1 à 0.
Comment distinguer mes positions des positions manuelles ?
Les positions ouvertes à la main ont un magic number égal à 0. Donnez à votre EA un magic number non nul et filtrez sur cette valeur.
CPositionInfo est-elle plus rapide que les fonctions natives ?
Elle encapsule les mêmes fonctions et n’apporte pas de gain de performance notable ; son intérêt est la lisibilité. Choisissez l’une ou l’autre et restez cohérent dans votre code.
- Ordres, positions et transactions : le modèle de MT5
- Comptes netting ou hedging
- La classe CTrade
- OrderSend et MqlTradeRequest
- OrderCheck : vérifier un ordre avant envoi
- Ouvrir une position au marché
- Ordres limites et stop
- Placer et modifier stop loss et take profit
- Coder un trailing stop
- Passer une position à break-even
- Fermer une position (totale ou partielle)
- Le magic number
- Lire l’historique des ordres et transactions
- OnTradeTransaction : réagir aux événements de trading
- Modes de remplissage (FOK, IOC, Return)
- Gérer spread et slippage dans un EA
- Calculer et normaliser la taille de lot
