Tivoli Service Desk 6.0 Developer's Toolkit - Guide de programmation TSD Script
Retour à la table des matières
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.
La boîte à outils du développeur fournit deux éléments conditionnels :
La boîte à outils du développeur fournit plusieurs éléments permettant de modifier le déroulement d'un programme :
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.
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;
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.
Si la condition est FALSE, l'un des trois événements suivants se produit :
La boîte à outils du développeur utilise des évaluations booléennes partielles. Cela signifie que si vous évaluez deux clauses :
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.
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.
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;
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) |
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.
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;
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;
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;
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.).
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;
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.
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.
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