MQL5 · Bases du langage
SymbolInfoDouble et SymbolInfoInteger : lire les propriétés d’un symbole en MQL5
Lire décimales, point, spread, stops level, volumes, valeur du tick et mode de trading d’un symbole avec SymbolInfoDouble, SymbolInfoInteger et SymbolInfoString, avec gestion des erreurs.
Les propriétés d’un symbole (décimales, taille du point, spread, distance minimale des stops, limites de volume, valeur du tick, devises, mode de trading) se lisent avec trois fonctions selon le type de la valeur : SymbolInfoDouble() pour les réels, SymbolInfoInteger() pour les entiers et booléens, SymbolInfoString() pour les textes. Chacune existe en deux variantes : l’une renvoie directement la valeur, l’autre renvoie true ou false et écrit la valeur dans une variable passée par référence. Un Expert Advisor robuste ne code jamais en dur une caractéristique de symbole : il la lit, car elle varie d’un instrument et d’un courtier à l’autre.
Cette page fait partie de la rubrique Les bases du langage MQL5. Pour les informations du compte (solde, marge, levier), voir AccountInfoDouble : lire les informations du compte.
Les signatures
D’après la documentation officielle :
double SymbolInfoDouble(string name, ENUM_SYMBOL_INFO_DOUBLE prop_id);
bool SymbolInfoDouble(string name, ENUM_SYMBOL_INFO_DOUBLE prop_id, double &double_var);
long SymbolInfoInteger(string name, ENUM_SYMBOL_INFO_INTEGER prop_id);
bool SymbolInfoInteger(string name, ENUM_SYMBOL_INFO_INTEGER prop_id, long &long_var);
string SymbolInfoString(string name, ENUM_SYMBOL_INFO_STRING prop_id);
bool SymbolInfoString(string name, ENUM_SYMBOL_INFO_STRING prop_id, string &string_var);
La première variante est la plus concise, mais elle ne permet pas de distinguer une valeur nulle légitime d’un échec : il faut alors appeler GetLastError(). La seconde rend la gestion d’erreur explicite et convient mieux aux lectures critiques, comme la valeur du tick utilisée dans un calcul de lot. La documentation liste les codes d’erreur possibles : 5040 (nom de symbole invalide), 4301 (symbole inconnu), 4302 (symbole non sélectionné dans le Market Watch) et 4303 (identifiant de propriété invalide).
Notez que SymbolInfoInteger() renvoie un long. Pour une propriété de type int ou énumération, une conversion explicite rend le code propre : (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS).
Les propriétés les plus utiles
Propriétés entières (SymbolInfoInteger)
| Identifiant | Type | Usage |
|---|---|---|
| SYMBOL_DIGITS | int | Nombre de décimales du prix |
| SYMBOL_SPREAD | int | Spread courant en points |
| SYMBOL_SPREAD_FLOAT | bool | Spread variable ou fixe |
| SYMBOL_TRADE_STOPS_LEVEL | int | Distance minimale des stops, en points |
| SYMBOL_TRADE_FREEZE_LEVEL | int | Distance de gel des ordres, en points |
| SYMBOL_TRADE_MODE | ENUM_SYMBOL_TRADE_MODE | Opérations autorisées sur le symbole |
| SYMBOL_FILLING_MODE | int (drapeaux) | Modes de remplissage autorisés |
| SYMBOL_EXPIRATION_MODE | int (drapeaux) | Modes d’expiration des ordres en attente |
| SYMBOL_SELECT | bool | Symbole sélectionné dans le Market Watch |
| SYMBOL_TRADE_CALC_MODE | ENUM_SYMBOL_CALC_MODE | Mode de calcul de la marge et du profit |
Propriétés réelles (SymbolInfoDouble)
| Identifiant | Usage |
|---|---|
| SYMBOL_BID / SYMBOL_ASK | Derniers prix bid et ask |
| SYMBOL_POINT | Valeur d’un point |
| SYMBOL_TRADE_TICK_SIZE | Pas minimal de variation du prix |
| SYMBOL_TRADE_TICK_VALUE | Valeur d’un tick pour un lot, en devise du compte |
| SYMBOL_TRADE_TICK_VALUE_PROFIT / _LOSS | Valeur du tick pour une position gagnante ou perdante |
| SYMBOL_TRADE_CONTRACT_SIZE | Taille du contrat |
| SYMBOL_VOLUME_MIN / _MAX / _STEP | Lot minimal, maximal et pas de volume |
| SYMBOL_SWAP_LONG / SYMBOL_SWAP_SHORT | Swaps des positions acheteuses et vendeuses |
Propriétés texte (SymbolInfoString)
SYMBOL_CURRENCY_BASE, SYMBOL_CURRENCY_PROFIT et SYMBOL_CURRENCY_MARGIN donnent la devise de base, la devise de profit et la devise de marge ; SYMBOL_DESCRIPTION donne la description du symbole.
Le mode de trading du symbole
SYMBOL_TRADE_MODE renvoie une valeur de ENUM_SYMBOL_TRADE_MODE : SYMBOL_TRADE_MODE_DISABLED (trading désactivé), SYMBOL_TRADE_MODE_LONGONLY (achats seulement), SYMBOL_TRADE_MODE_SHORTONLY (ventes seulement), SYMBOL_TRADE_MODE_CLOSEONLY (fermetures seulement) et SYMBOL_TRADE_MODE_FULL (aucune restriction). Vérifier cette propriété avant d’envoyer un ordre évite des refus comme 10017 Trading désactivé.
Prix courants : préférer SymbolInfoTick
SYMBOL_BID et SYMBOL_ASK donnent les derniers prix, mais la documentation de SymbolInfoDouble() recommande d’utiliser SymbolInfoTick() lorsqu’on cherche les informations du dernier tick. Cette fonction remplit une structure MqlTick avec bid, ask, last, volume et heure en un seul appel, ce qui garantit que les valeurs proviennent du même tick. La documentation précise également que si aucune cotation n’a été reçue depuis la connexion du terminal, la valeur demandée est indéterminée.
Symboles du Market Watch
Pour lire les propriétés d’un autre symbole que celui du graphique, il doit être sélectionné dans la fenêtre Market Watch, faute de quoi l’erreur 4302 est renvoyée. SymbolSelect(nom, true) l’y ajoute ; la fonction renvoie false en cas d’échec. C’est une étape indispensable dans un EA multi-symboles.
Exemple complet : fiche technique d’un symbole
//+------------------------------------------------------------------+
//| Script : fiche technique d'un symbole avant de le trader |
//+------------------------------------------------------------------+
#property script_show_inputs
input string InpSymbole = ""; // Symbole (vide = symbole du graphique)
void OnStart()
{
string sym = (InpSymbole == "") ? _Symbol : InpSymbole;
// Le symbole doit etre dans le Market Watch pour etre interroge
if(!SymbolSelect(sym, true))
{
PrintFormat("Impossible de selectionner %s, erreur %d", sym, GetLastError());
return;
}
// Lectures avec la variante a reference : l'echec est detectable
double tickValue = 0.0, tickSize = 0.0;
if(!SymbolInfoDouble(sym, SYMBOL_TRADE_TICK_VALUE, tickValue) ||
!SymbolInfoDouble(sym, SYMBOL_TRADE_TICK_SIZE, tickSize))
{
PrintFormat("Proprietes de tick indisponibles, erreur %d", GetLastError());
return;
}
int digits = (int)SymbolInfoInteger(sym, SYMBOL_DIGITS);
double point = SymbolInfoDouble(sym, SYMBOL_POINT);
long stops = SymbolInfoInteger(sym, SYMBOL_TRADE_STOPS_LEVEL);
long freeze = SymbolInfoInteger(sym, SYMBOL_TRADE_FREEZE_LEVEL);
bool flottant = (bool)SymbolInfoInteger(sym, SYMBOL_SPREAD_FLOAT);
double vMin = SymbolInfoDouble(sym, SYMBOL_VOLUME_MIN);
double vMax = SymbolInfoDouble(sym, SYMBOL_VOLUME_MAX);
double vStep = SymbolInfoDouble(sym, SYMBOL_VOLUME_STEP);
ENUM_SYMBOL_TRADE_MODE mode = (ENUM_SYMBOL_TRADE_MODE)SymbolInfoInteger(sym, SYMBOL_TRADE_MODE);
PrintFormat("%s (%s) : %d decimales, point %.*f, tick %.*f",
sym, SymbolInfoString(sym, SYMBOL_DESCRIPTION), digits, digits, point, digits, tickSize);
PrintFormat("Devises : base %s, profit %s, marge %s",
SymbolInfoString(sym, SYMBOL_CURRENCY_BASE),
SymbolInfoString(sym, SYMBOL_CURRENCY_PROFIT),
SymbolInfoString(sym, SYMBOL_CURRENCY_MARGIN));
PrintFormat("Volumes : min %.2f, max %.2f, pas %.2f | valeur du tick pour 1 lot : %.2f %s",
vMin, vMax, vStep, tickValue, AccountInfoString(ACCOUNT_CURRENCY));
PrintFormat("Stops level %I64d pts, freeze level %I64d pts, spread %s",
stops, freeze, flottant ? "variable" : "fixe");
PrintFormat("Mode de trading : %s", EnumToString(mode));
// Spread : propriete du courtier comparee au calcul a partir du dernier tick
MqlTick tick;
if(SymbolInfoTick(sym, tick) && point > 0.0)
PrintFormat("Spread annonce %I64d pts, calcule %.0f pts",
SymbolInfoInteger(sym, SYMBOL_SPREAD), (tick.ask - tick.bid) / point);
// Valeur monetaire d'un mouvement de 100 points pour 1 lot
if(tickSize > 0.0)
PrintFormat("100 points = %.2f %s pour 1 lot",
100 * point / tickSize * tickValue, AccountInfoString(ACCOUNT_CURRENCY));
}
Lancez ce script sur plusieurs instruments (une paire de devises, l’or, un indice) : les écarts de décimales, de pas de cotation, de valeur du tick et de distance minimale des stops montrent pourquoi aucune de ces valeurs ne doit être codée en dur.
Cas d’usage en trading
- Calcul du lot selon le risque : la valeur et la taille du tick convertissent une distance de stop en montant monétaire. Voir Calculer et normaliser la taille de lot.
- Placement des stops : un stop plus proche que
SYMBOL_TRADE_STOPS_LEVELpoints du prix courant est refusé. Lisez cette valeur au moment de placer ou de modifier un stop. - Filtre de spread :
SYMBOL_SPREADou le calcul ask moins bid alimentent un filtre qui bloque les entrées pendant les périodes de spread élevé. - Mode de remplissage : les drapeaux de
SYMBOL_FILLING_MODEindiquent les modes acceptés ; un mode non pris en charge provoque l’erreur 10030. - Normalisation : décimales, pas de cotation et pas de volume alimentent les fonctions de NormalizeDouble et précision des prix.
Propriétés fixes et propriétés variables
Toutes les propriétés n’évoluent pas au même rythme, et cela détermine où les lire dans le code.
- Propriétés stables : nombre de décimales, point, taille du contrat, devises, limites et pas de volume. Elles ne changent pas pendant la vie de l’EA dans la plupart des cas ; on peut les lire dans
OnInit()et les conserver dans des variables globales, en vérifiant au passage qu’elles sont cohérentes (pas de volume positif, point non nul). - Propriétés variables : bid, ask, spread, et valeur du tick lorsque la devise de profit du symbole diffère de la devise du compte, puisqu’elle dépend alors d’un taux de change. On les relit au moment où l’on s’en sert.
- Propriétés susceptibles de changer : mode de trading, distance minimale des stops ou de gel. Un courtier peut les modifier, par exemple autour d’annonces économiques ou en fin de semaine. Les relire avant chaque opération de trading ne coûte presque rien.
Lire une propriété dans OnInit() comporte un risque supplémentaire : au tout premier chargement, les données du symbole peuvent ne pas encore être disponibles. Si une valeur indispensable vaut 0, il est plus sûr de refuser l’initialisation ou de retarder le calcul au premier tick.
Pièges fréquents
- Lire un symbole absent du Market Watch : erreur 4302. Appelez
SymbolSelect()au préalable. - Ignorer l’échec de la lecture : avec la variante courte, une valeur 0 peut être une erreur. Utilisez la variante à référence pour les valeurs critiques.
- Coder en dur la taille du pip : le facteur 10 entre point et pip n’est pas universel. Raisonnez en points ou en pas de cotation.
- Utiliser SYMBOL_BID et SYMBOL_ASK séparément : deux appels peuvent lire deux ticks différents. Préférez
SymbolInfoTick(). - Mettre en cache des valeurs variables : le spread et la valeur du tick (pour les paires dont la devise de profit diffère de celle du compte) évoluent. Relisez-les au moment du calcul.
FAQ
Quelle différence entre SymbolInfoDouble et SymbolInfoInteger ?
Elles lisent des propriétés de types différents : SymbolInfoDouble pour les valeurs réelles (prix, point, volumes, valeur du tick), SymbolInfoInteger pour les entiers et booléens (décimales, spread, stops level, modes). Chaque identifiant appartient à une seule des deux énumérations.
Pourquoi SymbolInfoDouble renvoie-t-il 0 ?
Soit la propriété vaut réellement 0, soit la lecture a échoué : symbole inconnu, absent du Market Watch, identifiant invalide ou aucune cotation reçue. Utilisez la variante qui renvoie un booléen, ou appelez GetLastError() après la lecture.
Comment obtenir le spread en MQL5 ?
SymbolInfoInteger(symbole, SYMBOL_SPREAD) renvoie le spread en points. Vous pouvez aussi le calculer à partir du dernier tick : (ask – bid) / point, comme le fait l’exemple de la documentation.
Faut-il utiliser SYMBOL_BID ou SymbolInfoTick ?
Pour les prix du dernier tick, la documentation recommande SymbolInfoTick(), qui renvoie bid, ask, last, volume et heure de manière cohérente en un seul appel.
- 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
- Boucles for, while et do while
- É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
- AccountInfoDouble : lire les informations du compte
- Bien utiliser MetaEditor
