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

MQL5 · Bases du langage

Conditions en MQL5 : if, else, else if et switch

Brancher la logique d’un Expert Advisor avec if, else et switch : syntaxe, règles du switch, clauses de garde dans OnTick et erreurs classiques qui déclenchent de faux signaux.

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

En MQL5, if (condition) instruction; else instruction; exécute un bloc selon qu’une expression est vraie (non nulle) ou fausse (nulle). Pour tester plusieurs cas exclusifs, on enchaîne else if. Lorsque la décision porte sur une seule valeur entière comparée à une liste de constantes (un type d’ordre, un jour de la semaine, un mode choisi dans les paramètres), switch est plus lisible : chaque case désigne une valeur, break termine le cas et default traite tout le reste. Dans un Expert Advisor, ces deux instructions structurent toute la logique de décision : filtres, signaux, gestion des positions.

Cette page fait partie de la rubrique Les bases du langage MQL5. Les opérateurs utilisés dans les conditions sont détaillés dans Opérateurs et expressions.

L’instruction if

La forme minimale est if(expression) instruction;. L’expression est évaluée : si elle est non nulle, l’instruction s’exécute. Pour plusieurs instructions, on les regroupe dans un bloc entre accolades. La clause else facultative s’exécute lorsque l’expression est nulle.

Une bonne habitude consiste à toujours utiliser des accolades, même pour une seule instruction. Sans elles, l’ajout ultérieur d’une ligne de journalisation sous le if la sortirait de la condition sans que rien ne le signale à la lecture.

Le else ambigu

Avec des if imbriqués sans accolades, un else se rattache au if le plus proche qui n’a pas encore de else. Le code suivant est trompeur : l’indentation suggère que le else concerne le premier test, alors qu’il concerne le second.

if(positionOuverte)
   if(profit > 0)
      Print("Position gagnante");
else
   Print("Aucune position");   // en realite : position ouverte ET profit <= 0

Les accolades lèvent toute ambiguïté. C’est l’une des sources de bugs les plus difficiles à repérer en relecture.

Chaînes else if

Pour classer une valeur dans plusieurs plages, on enchaîne les tests. Ils sont évalués dans l’ordre, et seul le premier vrai est exécuté. L’ordre des tests compte donc : placez les cas les plus restrictifs en premier.

if(rsi >= 70.0)
   zone = "surachat";
else if(rsi <= 30.0)
   zone = "survente";
else
   zone = "neutre";

L’instruction switch

switch compare une expression à une série de constantes. La documentation fixe des règles précises :

  • l’expression doit être de type entier ;
  • chaque case est suivi d’une constante entière, d’une constante littérale ou d’une expression constante, qui ne peut contenir ni variable ni appel de fonction ;
  • deux case d’un même switch ne peuvent pas avoir la même valeur ;
  • default est facultatif et peut apparaître n’importe où ; si aucun cas ne correspond et qu’il n’y a pas de default, rien n’est exécuté ;
  • sans break, l’exécution continue dans les cas suivants jusqu’au prochain break.

Ce dernier point, le « fall-through », est à la fois un piège et un outil. Un break oublié exécute le code du cas suivant. À l’inverse, empiler plusieurs case sans instruction entre eux permet de partager un même traitement, par exemple pour regrouper les ordres d’achat (ORDER_TYPE_BUY, ORDER_TYPE_BUY_LIMIT, ORDER_TYPE_BUY_STOP).

Les énumérations étant des entiers, switch est le compagnon naturel d’un paramètre enum. Les chaînes ne sont en revanche pas acceptées : pour brancher selon un nom de symbole, il faut une chaîne de if.

Écrire des conditions de trading lisibles

Dans OnTick(), la logique d’un EA ressemble souvent à une série de contrôles successifs : le trading est-il autorisé, le spread est-il acceptable, sommes-nous dans les horaires, une position est-elle déjà ouverte, le signal est-il présent ? Empiler ces tests dans des if imbriqués produit un code en escalier difficile à suivre.

La technique des clauses de garde consiste à inverser chaque test et à sortir immédiatement avec return quand une condition n’est pas remplie. Le code reste plat, chaque filtre tient sur deux lignes, et l’on voit d’un coup d’œil dans quel ordre ils sont vérifiés. Cette approche est développée dans Filtres horaires, de spread et de volatilité.

Exemple complet : filtres et sélection du mode de lot

//+------------------------------------------------------------------+
//| EA : clauses de garde avec if, choix du mode avec switch         |
//+------------------------------------------------------------------+
enum ENUM_MODE_LOT
  {
   MODE_FIXE    = 0,   // Lot fixe
   MODE_SOLDE   = 1,   // Proportionnel au solde
   MODE_RISQUE  = 2    // Selon le risque et le stop
  };

input ENUM_MODE_LOT InpModeLot   = MODE_FIXE;  // Mode de calcul du lot
input double        InpLot       = 0.10;       // Lot fixe
input int           InpSpreadMax = 20;         // Spread maximum (points)
input int           InpHeureDeb  = 8;          // Heure de debut (serveur)
input int           InpHeureFin  = 20;         // Heure de fin (serveur)

double CalculerLot()
  {
   double lot = InpLot;
   switch(InpModeLot)
     {
      case MODE_FIXE:
         lot = InpLot;
         break;
      case MODE_SOLDE:
         // 0.01 lot par tranche de 1000 unites de solde (exemple pedagogique)
         lot = 0.01 * MathFloor(AccountInfoDouble(ACCOUNT_BALANCE) / 1000.0);
         break;
      case MODE_RISQUE:
         // calcul detaille dans la page consacree a la taille de lot
         lot = InpLot;
         break;
      default:
         Print("Mode de lot inconnu, lot fixe utilise");
         break;
     }
   return(lot);
  }

void OnTick()
  {
   // Garde 1 : trading autorise par le terminal et pour ce programme
   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED) || !MQLInfoInteger(MQL_TRADE_ALLOWED))
      return;

   // Garde 2 : spread acceptable
   if(SymbolInfoInteger(_Symbol, SYMBOL_SPREAD) > InpSpreadMax)
      return;

   // Garde 3 : plage horaire (heure du serveur)
   MqlDateTime t;
   TimeCurrent(t);
   if(t.hour < InpHeureDeb || t.hour >= InpHeureFin)
      return;

   // Garde 4 : une seule position a la fois sur ce symbole
   if(PositionSelect(_Symbol))
      return;

   double lot = CalculerLot();
   if(lot <= 0.0)
     {
      Print("Lot calcule nul : solde insuffisant pour ce mode");
      return;
     }

   // Ici : test du signal puis envoi de l'ordre
   PrintFormat("Conditions reunies, lot propose : %.2f", lot);
  }

Chaque garde correspond à une règle métier et peut être commentée, désactivée ou journalisée indépendamment. Le switch traite le paramètre enum cas par cas, avec un default défensif qui signale une valeur inattendue. Le calcul complet d’un lot selon le risque est traité dans Calculer et normaliser la taille de lot.

Conditionner l’action au résultat d’une fonction

Beaucoup de fonctions MQL5 signalent leur réussite par leur valeur de retour : true/false pour SymbolInfoTick() ou PositionSelect(), un nombre d’éléments ou -1 pour CopyBuffer() et CopyRates(), un handle ou INVALID_HANDLE pour les fonctions d’indicateurs. Le réflexe à prendre est d’envelopper chaque appel dans un if qui teste ce résultat avant d’utiliser les données. Un tableau de valeurs d’indicateur non rempli contient des valeurs indéterminées ou anciennes ; un signal calculé dessus n’a aucune valeur.

Ce test s’accompagne idéalement d’un message dans le journal indiquant la fonction en échec et le code renvoyé par GetLastError(). Lorsque la condition d’erreur est passagère (historique pas encore chargé, par exemple), un simple return suffit : le tick suivant retentera l’opération. Lorsque l’erreur est structurelle (handle invalide dans OnInit()), il vaut mieux arrêter le programme en renvoyant INIT_FAILED.

if ou opérateur ternaire ?

Pour choisir entre deux valeurs selon une condition simple, l’opérateur ?: produit une ligne compacte : double prixEntree = achat ? ask : bid;. Il ne remplace pas if lorsque chaque branche doit exécuter plusieurs instructions ou appeler des fonctions ayant des effets (envoi d’ordre, écriture dans un fichier). La lisibilité doit guider le choix.

Pièges fréquents

  • Point-virgule après le if : if(signal); Acheter(); exécute Acheter() dans tous les cas, car le ; constitue une instruction vide.
  • Affectation au lieu de comparaison : if(x = 0) affecte 0 et teste une valeur nulle, donc toujours fausse.
  • break oublié dans un switch : le cas suivant est exécuté aussi. Si le fall-through est voulu, signalez-le par un commentaire.
  • Égalité stricte entre double : if(prix == niveau) n’est presque jamais vrai. Comparez avec une tolérance ou testez un franchissement (< puis >=).
  • Conditions qui appellent des fonctions de trading : une fonction comme PositionSelect() modifie la position sélectionnée. Évitez de la cacher au milieu d’une expression longue où son effet passe inaperçu.
  • Valeur de retour ignorée : une condition qui s’appuie sur un prix ou un indicateur non disponible (0 ou valeur vide) peut déclencher un faux signal. Vérifiez d’abord que la donnée est valide.

Les mêmes principes s’appliquent aux conditions de sortie de boucle, présentées dans Boucles for, while et do while.

FAQ

Peut-on utiliser switch avec une chaîne de caractères ?

Non. L’expression d’un switch doit être de type entier et chaque case doit être une constante entière. Pour comparer des chaînes, utilisez une suite de if et else if, ou convertissez la chaîne en valeur d’énumération au préalable.

Que se passe-t-il si j’oublie un break dans un switch ?

L’exécution continue dans les cas suivants jusqu’au prochain break ou jusqu’à la fin du switch. Ce comportement est voulu par le langage, mais il est rarement souhaité : ajoutez un break à la fin de chaque cas.

Faut-il préférer des if imbriqués ou des clauses de garde ?

Dans un gestionnaire comme OnTick, les clauses de garde sont généralement plus lisibles : chaque condition non remplie provoque un return immédiat, et le code reste plat. Les if imbriqués conviennent pour deux niveaux au maximum.

Une condition sur un double peut-elle être vraie si la valeur vaut 0.0 ?

Une expression est fausse lorsqu’elle vaut zéro. if(valeur) sur un double est donc faux pour 0.0 et vrai pour toute autre valeur, y compris très petite. Écrivez plutôt une comparaison explicite comme valeur > 0.0.

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.