Tivoli Service Desk 6.0 Developer's Toolkit - Guide de programmation TSD Script

Chapitre 3 : Eléments conditionnels et de contrôle

Retour à la table des matières


Introduction

Ce chapitre présente les éléments conditionnels et de contrôle qui permettent de gérer des tests ainsi que les réponses aux conditions de test. Ces éléments permettent également de modifier le déroulement d'un programme ou de répéter des actions autant de fois que nécessaire.

Eléments conditionnels

La boîte à outils du développeur fournit deux éléments conditionnels :

Eléments de contrôle

La boîte à outils du développeur fournit plusieurs éléments permettant de modifier le déroulement d'un programme :

L'instruction IF

Format de l'instruction IF

L'instruction IF de la boîte à outils du développeur se présente sous la forme :

IF <condition> THEN
  <liste-instructions>
ELSIF <2nde condition> THEN
  <liste-instructions>
ELSE
  <liste-instructions>
  END; 

Les instructions ELSIF et ELSE ne sont pas obligatoires si la vérification ne porte que sur une seule condition.

Exemples d'instruction IF

Voici quelques exemples d'instructions IF :

IF (age < 18) OR (age > 90) THEN
  WRITELN('Age incorrect, entrez une autre valeur');
  END; 
IF display = 'CGA' THEN
  LoadCGADriver;
ELSIF display = 'MCGA' THEN
  LoadMCGADriver;
ELSIF display = 'EGA' THEN
  LoadEGADriver;
ELSE
  LoadVGADriver;
  END; 
IF processor = '8086' THEN
  maxMem := 640000;
  operatingSystem := 'DOS';
ELSE
  maxMem := 16000000;
  operatingSystem := 'OS/2';
(* operatingSystem correspond à une chaîne *)
  END;


Conditions True

IF et ELSIF sont toujours suivis d'une condition booléenne. Si cette condition est TRUE, les instructions figurant à la suite de IF et ELSIF sont exécutées.

Conditions False

Si la condition est FALSE, l'un des trois événements suivants se produit :

Evaluation booléenne partielle

La boîte à outils du développeur utilise des évaluations booléennes partielles. Cela signifie que si vous évaluez deux clauses :


L'instruction WHEN

Les instructions WHEN correspondent à un type particulier d'instructions IF. Elles permettent d'effectuer des opérations basées sur la valeur d'une variable ou d'une expression.

Exemple d'instruction IF

Soit l'instruction IF suivante :

IF i*j = 1 THEN
  WriteOne;
ELSIF i*j = 2 THEN
  WriteTwo;
ELSIF i*j = 3 THEN
  WriteThree;
ELSE
  WriteOther;
  END; 

Dans l'exemple précédent, la vérification de la valeur renvoyée par l'expression i*j implique que l'expression sera recalculée pour chaque valeur d'entrée. Si i*j est supérieur à 3, l'expression i*j sera évaluée à trois reprises.

Cette méthode présente deux inconvénients :

Une méthode plus satisfaisante consiste à affecter la valeur de i*j à une variable locale, puis à utiliser cette variable dans l'instruction IF.

Exemple d'instruction WHEN

Pour assurer une meilleure gestion au niveau de la maintenance et des performances, il est préférable d'utiliser une instruction WHEN plutôt qu'une instruction IF.

L'instruction WHEN de la boîte à outils du développeur fournit un meilleur moyen d'évaluer une condition, comme le montre l'exemple ci-dessous.

WHEN i*j IS 1 THEN
  WriteOne;
ELSWHEN 2 THEN
  WriteTwo;
ELSWHEN 3 THEN
  WriteThree;
ELSE
  WriteOther;
  END; 

L'instruction WHEN évalue une expression une seule fois, puis elle la compare à chacune des valeurs de référence. L'expression doit correspondre à un type de données simple, à un nombre entier ou à une chaîne.

Remarque : Lorsqu'elle est utilisée avec des chaînes, l'instruction WHEN n'effectue pas la distinction entre les majuscules et les minuscules.

Vous pouvez également indiquer plusieurs valeurs de comparaison en utilisant un format délimité par des virgules, comme dans l'exemple suivant :

WHEN i*j IS 1,2,3 DO
  WriteOne;
ELSWHEN 4,5,6 DO
  WriteTwo;
ELSWHEN 7,8,9 DO
  WriteThree;
ELSE
  WriteOther;
  END; 

Boucles FOR

L'élément de boucle FOR permet d'exécuter une ou plusieurs instructions, un nombre prédéterminé de fois. L'élément FOR se présente sous la forme suivante :

FOR <paramètre-boucle>:=<limite-inf> TO <limite-sup> DO
  <liste-instructions>
  END; 

Les éléments constitutifs de cet élément de boucle sont présentés dans le tableau suivant :

Elément Description
<paramètre-boucle> Variable entière dont la valeur est comprise entre <limite-inf> et <limite-sup> (ces deux valeurs étant incluses)
<limite-inf> Expression entière évaluée au début de la boucle et affectée à <paramètre-boucle>
<limite-inf> Expression entière qui est évaluée une fois au début de la boucle et qui est comparée à la valeur de <paramètre-boucle> chaque fois qu'elle apparaît dans la boucle
<liste-instructions> Une ou plusieurs instructions de la boîte à outils du développeur exécutées pour chaque valeur de <paramètre-boucle> entre <limite-inf> et <limite-sup> (incluses)

Exemple d'instruction FOR

L'exemple suivant illustre l'utilisation la plus simple de l'instruction FOR. Cet exemple montre l'affichage d'une même chaîne à dix reprises. La valeur de la variable i ne figure pas dans la liste des instructions.

FOR i:=1 TO 10 DO
  WinWriteLN(myWindow,'Hello');
  END; 

L'exemple suivant est légèrement plus complexe.

FOR i:=j TO k*3 DO
  WinWriteLN(myWindow,'i = ' & i);
  END; 

Remarque : Si la limite inférieure est égale à la limite supérieure, la liste d'instructions est exécutée une seule fois. Si elle excède la limite supérieure, la liste d'instructions n'est pas exécutée.

Utilisation de DOWNTO

Le mot clé DOWNTO peut être remplacé par TO afin que la boucle soit prise en compte à partir de la valeur supérieure et jusqu'à la valeur inférieure, comme le montre l'exemple suivant :

FOR i:=10 DOWNTO 1 DO
  WinWriteLN(myWindow,i);
  END;


Utilisation de FOR dans des listes

L'instruction FOR peut être d'une autre utilité pour les variables de type LIST :

FOR <paramètre-liste> DO
  <liste-instructions>
  END; 

Ici, la liste d'instructions est exécutée pour chaque élément du paramètre de liste. Le pointeur d'élément en cours du paramètre de liste, $Current, est initialisé afin de désigner le premier élément de la liste. A la fin de l'exécution de la liste d'instructions, le pointeur d'élément est avancé. Cela permet à une ou plusieurs instructions d'être exécutées pour tous les éléments d'une liste.

Soit l'exemple suivant :

ListInsert(myList,'One');
ListInsert(myList,'Two');
ListInsert(myList,'Three');
FOR myList DO
  WinWriteLN(myWindow,myList[$Current]);
  END; 

Boucles REPEAT

L'élément de boucle REPEAT effectue un ensemble d'instructions une fois, puis poursuit leur exécution jusqu'à ce qu'une condition donnée devienne TRUE (soit vérifiée).
L'élément de boucle REPEAT se présente sous la forme suivante :

REPEAT
  <liste-instructions>
UNTIL <condition>; 

Le code suivant permet d'afficher la chaîne 'Hello' dix fois à l'écran .

i:=1;
REPEAT
  WinWriteLN(myWindow,'Hello');
  i:=i + 1;
UNTIL i > 10; 

Expressions booléennes

Dans l'exemple précédent, <condition> correspond à une expression booléenne qui est déterminée à chaque passage de la boucle. Si elle correspond à FALSE, les instructions figurant dans <liste-instructions> sont exécutées à nouveau.
Les expressions booléennes peuvent être constituées de clauses reliées par :

Une clause est composée de deux expressions de types de données compatibles séparées par un opérateur relationnel (=, >, <, etc.).

Boucles WHILE

L'élément de boucle WHILE est identique à l'élément de boucle REPEAT à l'exception de la condition "exit" qui est contrôlée au début plutôt qu'à la fin de la boucle. Les instructions figurant dans un élément de boucle REPEAT sont exécutées au moins une fois, tandis que les instructions figurant dans un élément de boucle WHILE ne sont pas exécutées du tout si la condition de la boucle présente initialement la valeur FALSE.

Les éléments de boucle WHILE se présentent sous la forme suivante :

WHILE <condition> DO
  <liste-instructions>
  END; 

Dans le programme suivant, la chaîne 'Hello' s'affiche à l'écran à dix reprises

i:=1;
WHILE i <= 10 DO
  WinWriteLN('Hello');
  i:=i + 1;
  END; 

Les instructions Exit et ExitLoop

Exit

L'instruction Exit permet de sortir d'un appel de fonction ou de procédure. Lors de l'émission de cette instruction, la routine en cours s'arrête complètement, même si elle est placée dans une boucle FOR, REPEAT ou WHILE.

ExitLoop

Comme son nom l'indique, l'instruction ExitLoop permet de sortir d'une boucle avant que les conditions de fin ne prennent la valeur TRUE.

Dans l'exemple suivant, une boucle a été créée afin de lire et d'imprimer toutes les lignes du tableau de la base de données EMPLOYEES. Si l'instruction SQLFetch échoue en renvoyant une valeur inférieure à 1 (indiquant ainsi une erreur ou la fin de l'ensemble de résultats), l'instruction ExitLoop entraîne l'arrêt de l'exécution de la boucle. L'instruction figurant après la boucle correspond à celle qui sera exécutée immédiatement après.

Exemple de ExitLoop

L'exemple suivant illustre l'utilisation de l'instruction ExitLoop :

VARIABLES
  i: Integer;
  cursor: SQLCursor;
  employee: EmployeeRecord;
ACTIONS 
  i:=SQLSelect(cursor,'SELECT * FROM EMPLOYEES');
  WHILE i > 0 DO
    i:=SQLFetch(cursor,employee);
    IF i < 1 THEN
      ExitLoop;
  END; 
    PrintEmployee(employee);
  END;
  SQLCloseCursor(cursor);

Tivoli Service Desk 6.0 Developer's Toolkit - Guide de programmation TSD Script

Retour à la table des matières

Copyright