MQL4 · Codes d’erreur
GetLastError en MQL4 : lire, journaliser et traiter les codes d’erreur
GetLastError renvoie le dernier code d’erreur d’un programme MQL4, puis le remet à zéro. Bien l’appeler, au bon moment et une seule fois, conditionne tout le diagnostic de vos Expert Advisors.
GetLastError() est la fonction qui renvoie, sous forme d’entier, le code de la dernière erreur survenue pendant l’exécution d’un programme MQL4. Sa signature est minimale : int GetLastError();. Le point essentiel, souvent ignoré, figure dans la documentation officielle : après l’appel, le contenu de la variable _LastError est remis à zéro. Autrement dit, le code n’est lisible qu’une fois. Si vous appelez GetLastError() dans un Print, puis de nouveau dans un if, le second appel renverra 0 et votre traitement d’erreur ne se déclenchera jamais.
Cette page explique comment l’utiliser correctement : à quel moment l’appeler, comment éviter les codes « fantômes » hérités d’un appel précédent, comment obtenir un libellé lisible, et comment bâtir une fonction de journalisation que vous réutiliserez dans tous vos EA. Elle constitue la porte d’entrée de la rubrique Codes d’erreur MQL4.
Les outils disponibles en MQL4
Quatre éléments servent à la gestion des erreurs :
| Élément | Rôle |
|---|---|
GetLastError() | Renvoie le dernier code d’erreur, puis remet _LastError à zéro |
_LastError | Variable prédéfinie contenant le dernier code, lisible sans la remettre à zéro |
ResetLastError() | Remet explicitement le code d’erreur à zéro |
ErrorDescription() | Fonction de la bibliothèque stdlib.mqh qui renvoie un libellé texte en anglais |
_LastError est utile pour consulter le code sans l’effacer, par exemple dans une fonction d’affichage intermédiaire. ErrorDescription() n’est pas une fonction native : elle est fournie dans le fichier d’inclusion stdlib.mqh livré avec le terminal, qu’il faut inclure avec #include <stdlib.mqh>.
La règle : tester la valeur de retour d’abord
L’erreur la plus courante consiste à appeler GetLastError() systématiquement après chaque fonction, sans regarder si la fonction a échoué. Or la variable d’erreur n’est pas remise à zéro quand une fonction réussit : elle peut contenir un code laissé par un appel antérieur. Vous risquez alors d’afficher une erreur qui n’a rien à voir avec l’opération en cours.
La bonne séquence est la suivante :
- appeler
ResetLastError()juste avant l’opération sensible, pour partir d’un état propre ; - exécuter la fonction et tester sa valeur de retour (
-1pourOrderSend,falsepourOrderModify,OrderClose,OrderSelect…) ; - seulement en cas d’échec, appeler
GetLastError()une seule fois et stocker le résultat dans une variable locale ; - travailler ensuite uniquement avec cette variable.
Une fonction de journalisation réutilisable
Le code suivant regroupe ces bonnes pratiques. La fonction LogError reçoit le contexte (nom de l’opération) et le code déjà lu, et écrit une ligne exploitable dans l’onglet Experts. L’exemple d’utilisation montre un OrderModify sur un ordre sélectionné.
//+------------------------------------------------------------------+
//| Journalisation des erreurs MQL4 |
//+------------------------------------------------------------------+
#property strict
#include <stdlib.mqh> // fournit ErrorDescription()
#include <stderror.mqh> // constantes ERR_...
//--- écrit une ligne d'erreur lisible dans l'onglet Experts
void LogError(const string context, const int code)
{
PrintFormat("[%s] %s échec : erreur %d (%s) | Bid=%s Ask=%s",
Symbol(), context, code, ErrorDescription(code),
DoubleToString(Bid, Digits), DoubleToString(Ask, Digits));
}
//--- exemple : modifier le stop loss d'un ordre identifié par son ticket
bool ModifyStopLoss(const int ticket, const double newSl)
{
if(!OrderSelect(ticket, SELECT_BY_TICKET))
{
int err = GetLastError(); // lu une seule fois
LogError("OrderSelect", err);
return false;
}
double sl = NormalizeDouble(newSl, Digits);
ResetLastError(); // part d'un état propre
bool ok = OrderModify(ticket, OrderOpenPrice(), sl,
OrderTakeProfit(), 0, clrNONE);
if(!ok)
{
int err = GetLastError(); // le code est mémorisé ici
LogError("OrderModify #" + IntegerToString(ticket), err);
// la suite du traitement utilise err, jamais un second GetLastError()
return false;
}
return true;
}
Remarquez que LogError reçoit le code en paramètre au lieu d’appeler elle-même GetLastError(). Cela permet de journaliser puis de décider d’une reprise avec la même valeur. Si vous préférez une version plus courte, vous pouvez lire _LastError dans la fonction de journalisation : la variable ne sera pas remise à zéro par cette lecture.
Décider de la suite selon le code
Une fois le code stocké, un switch permet de séparer les erreurs passagères des erreurs de logique. Les premières justifient un nouvel essai après RefreshRates() ; les secondes doivent interrompre l’opération.
//--- renvoie true si un nouvel essai a une chance de réussir
bool IsRetryable(const int code)
{
switch(code)
{
case ERR_PRICE_CHANGED: // 135
case ERR_OFF_QUOTES: // 136
case ERR_REQUOTE: // 138
case ERR_TRADE_CONTEXT_BUSY: // 146
case ERR_SERVER_BUSY: // 4
case ERR_NO_CONNECTION: // 6
case ERR_TRADE_TIMEOUT: // 128
return true;
default:
return false; // 130, 131, 134, 4109… : corriger, pas réessayer
}
}
Les constantes comme ERR_REQUOTE ou ERR_TRADE_CONTEXT_BUSY sont définies dans le fichier d’inclusion stderror.mqh (#include <stderror.mqh>) ; les utiliser plutôt que les nombres bruts rend le code plus lisible. La décision de reprise est une politique de votre EA : la documentation officielle se contente de nommer les erreurs. Pour le détail de chaque cas, consultez par exemple Erreur 138 : requote ou Erreur 146 : contexte de trading occupé.
Où placer la logique de reprise
Une erreur passagère ne doit pas transformer OnTick() en boucle d’attente. Deux architectures fonctionnent bien. La première consiste à tenter l’opération un petit nombre de fois dans la même exécution, avec une courte pause (Sleep) et un RefreshRates() entre deux essais : c’est adapté aux recotations et au contexte occupé, qui se résolvent en quelques centaines de millisecondes. La seconde consiste à mémoriser l’intention (par exemple « fermer l’ordre 123456 ») dans une variable globale du programme et à la retenter au tick suivant : c’est préférable lorsque le marché est agité ou la connexion instable, car l’EA reste réactif et ne bloque pas le fil de trading.
Dans les deux cas, plafonnez le nombre de tentatives et journalisez chacune d’elles avec son code. Le testeur de stratégie ne produit presque jamais de recotation ni de contexte occupé : une logique de reprise qui « fonctionne » en backtest n’a en réalité pas été éprouvée, et doit être revérifiée sur un compte de démonstration. Enfin, pensez à IsStopped() dans les boucles d’attente : si l’utilisateur retire l’EA du graphique, la boucle doit s’interrompre immédiatement au lieu de poursuivre ses essais.
Cas d’usage en trading
Erreurs hors trading
GetLastError() ne sert pas qu’aux ordres. Une division par zéro, un indice de tableau hors limites ou un fichier introuvable produisent aussi des codes (famille 4000 et 5000). Dans un indicateur personnalisé appelé par iCustom, un échec de chargement se traduit également par un code d’erreur. Le même schéma « tester le retour, lire une fois, journaliser » s’applique.
Contexte du journal
Un code seul est rarement suffisant. Ajoutez au message les éléments qui permettront de comprendre l’échec a posteriori : prix Bid et Ask au moment de l’envoi, niveaux de stop demandés, volume, valeur de MarketInfo(Symbol(), MODE_STOPLEVEL). Pour une erreur 130, par exemple, connaître la distance réelle entre le prix et le stop est indispensable. La page Déboguer en MQL4 complète ces conseils avec l’usage du débogueur de MetaEditor.
Pièges fréquents
- Double appel :
Print("Erreur ", GetLastError()); if(GetLastError()==138) ...ne fonctionne jamais, le second appel renvoie 0. - Code périmé : appeler
GetLastError()après une fonction qui a réussi peut renvoyer une ancienne erreur. Testez toujours le retour d’abord. - Appel trop tardif : entre l’échec et la lecture du code, n’appelez pas d’autre fonction susceptible de modifier l’erreur.
- Inclusion oubliée : sans
#include <stdlib.mqh>,ErrorDescription()provoque une erreur de compilation, décrite dans Erreurs de compilation MQL4. - Valeur 1 sur
OrderModify: le code 1 (ERR_NO_RESULT) signifie que vous avez envoyé des valeurs identiques à celles de l’ordre. Ce n’est pas une panne, mais un appel inutile à éviter.
Questions fréquentes
Pourquoi GetLastError renvoie-t-il 0 alors que mon ordre a échoué ?
Probablement parce que le code a déjà été lu par un appel précédent. La documentation précise que le contenu de _LastError est remis à zéro après l’appel. Stockez la valeur dans une variable dès le premier appel et réutilisez-la.
Quelle différence entre GetLastError et _LastError ?
_LastError est la variable qui contient le code ; GetLastError() en renvoie la valeur puis la remet à zéro. Lire _LastError directement ne l’efface pas.
Où trouver ErrorDescription ?
Dans le fichier stdlib.mqh fourni avec MetaTrader 4, dans le dossier MQL4\Include. Ajoutez #include <stdlib.mqh> en tête de votre programme pour l’utiliser.
Faut-il appeler ResetLastError avant chaque fonction ?
Ce n’est pas obligatoire si vous testez correctement la valeur de retour, mais c’est une bonne habitude avant les opérations de trading : vous êtes certain que le code lu ensuite provient bien de cet appel.
- Erreur 129 : prix invalide
- Erreur 130 : stops invalides
- Erreur 131 : volume invalide
- Erreur 133 : trading interdit
- Erreur 134 : fonds insuffisants
- Erreur 135 : prix modifié
- Erreur 136 : pas de prix
- Erreur 138 : requote
- Erreur 145 : modification refusée (trop proche)
- Erreur 146 : contexte de trading occupé
- Erreur 148 : trop d’ordres
- Erreur 4051 : paramètre invalide
- Erreur 4107 : prix invalide
- Erreur 4108 : ticket invalide
- Erreur 4109 : trading non autorisé
- Erreurs 4110 et 4111 : achats ou ventes non autorisés
- Erreurs de compilation MQL4
