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

Chapitre 2 : Types de données

Retour à la table des matières


Introduction

Ce chapitre présente les types de données les plus fréquemment utilisés dans la boîte à outils du développeur. Outre la présentation de ces types de données, vous trouverez des informations sur les constantes, les variables et les expressions.

Types de données simples

Les types de données déterminent les propriétés des données contenues dans une variable ou une constante. Les propriétés admises sont :

Types de données de la boîte à outils du développeur

La boîte à outils du développeur présente six types de données simples.

Autres types de données

Types de descripteur

Un descripteur est une variable qui comporte l'adresse d'une autre variable. Une adresse correspond à l'emplacement d'une variable. Un descripteur permet à un programme d'accéder à une ressource donnée.

Les types de descripteurs sont d'une utilisation spécifique et ne dérivent d'aucun autre type. Les développeurs utilisent les descripteurs pour identifier une entité logique à partir de laquelle des opérations sont effectuées. La liste suivante présente des types de descripteurs :

Types de paramètres externes

Les types de paramètres externes correspondent à des versions annotées de types simples. Grâce à eux l'interpréteur de la boîte à outils du développeur convertit plus facilement les valeurs de la boîte à outils du développeur au type C ou Pascal adéquat avant l'appel d'une DLL externe :

Types d'ensembles

Les trois types d'ensembles suivants ne se suffisent pas à eux-mêmes. Ils doivent être utilisés en association avec d'autres types afin de constituer des types définis par l'utilisateur :

Constantes

Les constantes correspondent à des éléments nommés qui restent inchangés ou constants tout au long de l'exécution d'un programme. Toutes les déclarations de constantes sont effectuées dans la section CONSTANTS d'une base de connaissances.

Déclaration d'une constante

Pour déclarer une constante dans une base de connaissances, vous devez :

Les déclarations de constantes, comme toute instruction de la boîte à outils du développeur, se terminent toujours par un point virgule (;).

L'exemple suivant illustre quelques exemples de déclarations de constantes avec différents types de données :

CONSTANTS
   (* constantes de chaîne *)
   fileName IS 'MYFILE.DAT';
   pathName IS 'EADVISOR\ADVISOR\DATA';
   driveName IS 'E:';
  (* constantes de nombre entier *)
  MAX_EMPLOYEES IS 500;
  ERROR_CODE IS -1;
  (* constantes de réel *)
  PI_VALUE IS 3.14159;
  MAX_SALARY IS 999999.99;
  LO_VALUE IS -5134.1348;
  (* constantes booléennes *)
  SAVE_TO_DISK IS TRUE;
  OVERWRITE_FILE IS FALSE;
  (* constantes de date *)
  CHRISTMAS IS {12,25,1996}: DATE; 
  BIRTH_DAY IS {2,13,1956}: DATE;
  (* constantes d'heure *)
  START_OF_DAY IS {8,30,0}: TIME;
  END_OF_DAY IS {18,0,0}: TIME; 

Remarque : Les utilisateurs internationaux doivent se rappeler que l'ordre des éléments constitutifs d'une date initialisée par la boîte à outils du développeur est (mois, jour, année). Cet ordre ne change pas en fonction de l'environnement local.

Variables

Les variables sont des éléments nommés qui comportent des types de données modifiables lors de l'exécution d'un programme. Les variables sont déclarées dans la section VARIABLES d'une base de connaissances.

Déclaration d'une variable

Pour déclarer une variable dans une base de connaissances, vous devez :

Vous pouvez déclarer plusieurs variables de même type en séparant leur nom par des virgules, comme le montre l'exemple suivant :

VARIABLES
  first_name, last_name        : STRING;
  i,j                          : INTEGER;
  salary                       : REAL;
  married                      : BOOLEAN;
  entryDate                    : DATE;
  startTime                    : TIME; 

Affectation de valeurs à des variables

Pour affecter des valeurs à des variables, utilisez l'opérateur d'affectation (:=).

Le fragment de code suivant présente quelques affectations de variables pour les variables définies dans l'exemple précédent :

first_name        := 'Amy';
last_name         := 'Alec';
i                 := 7;
j                 := 32;
salary            := 37500.00;
married           := FALSE;
entryDate         := {1,31,1991}: DATE;
startTime         := {10,30,0}: TIME; 

Conversions de type de données

Vous pouvez avoir besoin de convertir des types de données. Les conversions de données interviennent lors de changements de présentation des informations. Par exemple, vous pouvez remplacer une représentation binaire par une représentation décimale ou héxadécimale, ou encore des nombres entiers par des chaînes.

Conversion de type de données simple

La boîte à outils du développeur indique les valeurs à convertir par des accolades {}.

Dans l'exemple suivant, la valeur comprise entre les accolades est convertie en nombre entier :

i := {s}: INTEGER; 

Lorsque la boîte à outils du développeur rencontre cette ligne  :

La conversion d'une valeur ne supprime pas la valeur d'origine.

Calcul avec une conversion de type de données

L'exemple suivant présente un exemple plus complexe de conversion de données dans lequel la boîte à outils du développeur calcule le nombre de jours séparant deux dates données :

d1                := {1,1,1990}: DATE;
d2                := $Today;
daysBetween        = {d2}: INTEGER - {d1}: INTEGER; 

Pour effectuer ce calcul, la boîte à outils du développeur utilise les valeurs de date stockées dans {d1} et {d2}, les convertit en valeurs juliennes et les soustrait.

Cet exemple suppose que {d1} et {d2} correspondent à des variables de date et que la variable daysBetween corresponde à un nombre entier.

Erreurs d'affectation

La boîte à outils du développeur présente un langage fortement dépendant des types qu'il utilise. En effet, si vous affectez une variable d'un type à une variable d'un autre type, une erreur se produit.

Par exemple, soit entryDate une variable de date et startTime une variable d'heure, l'affectation suivante engendre une erreur d'exécution :

entryDate := startTime; 

Conversions automatiques de type

La boîte à outils du développeur convertit les nombres entiers et réels automatiquement. Soit, par exemple, la variable i correspondant à un nombre entier. L'instruction

i := 37.0; 

entraîne l'affectation de la valeur 37 à la variable i sans qu'aucune conversion de type ne soit nécessaire.
De même, si r correspond à un nombre réel, l'instruction

r := i; 

entraîne l'affectation de la valeur 37.0 à la variable r.

Les expressions combinées sont traitées en tant que nombres réels jusqu'à ce que l'affectation soit faite et ceci afin de conserver une certaine précision.

En outre, la boîte à outils du développeur convertit automatiquement tous les types de données en chaînes si nécessaire. Par exemple, l'instruction :

s := i; 

affecte la valeur de chaîne 37 à la variable s.

Expressions de chaînes avec des types de données simples

Fonctions d'expression de chaîne

Dans la boîte à outils du développeur, une chaîne correspond à une séquence de caractères entourée d'apostrophes. La boîte à outils du développeur fournit des instructions et des opérateurs de manipulation de chaînes qui vous permettent :

Instructions et opérateurs

Les instructions et les opérateurs de manipulation de chaîne sont répertoriés dans la liste suivante :

Expressions réelles et entières

Opérateurs et expressions arithmétiques

La boîte à outils du développeur supporte les opérateurs et expressions arithmétiques, tels que présentés dans le tableau suivant :

Opérateur Description
+ Ajoute deux expressions numériques (i:=3+5)
- Soustrait une expression numérique à une autre (r:=3.7-2.0)
* Multiplie deux expressions numériques (i:=3.0*6)
/ Divise deux expressions numériques (r:=3.0/4.0)
MOD Calcule le reste de la division d'un nombre entier par un autre (6 MOD 4=2)

Opérateurs supplémentaires

Outre ces opérateurs, la boîte à outils du développeur supporte les fonctions suivantes :

Trigonométrique Logarithmique Exponentielle
Sin Log Exp
Cos Ln Power
Tan Sqrt -
ACos - -
ASin - -
ATan - -
CosH - -
SinH - -
TanH - -


Expressions booléennes

Opérateurs logiques

Les opérateurs logiques AND, OR et NOT permettent de créer des expressions booléennes complexes telles que :

b := (i > 0) AND (j = 0); 

La boîte à outils du développeur effectue une évaluation booléenne partielle. Ce type d'évaluation permet de garantir une évaluation des expressions booléennes dans les limites nécessaires pour déterminer leur valeur.

Dans l'exemple précédent, si i est égal à 0, la variable b prend la valeur FALSE avant que j ne soit évalué. La règle établit que :

Opérateurs relationnels

La boîte à outils du développeur fournit les opérateurs relationnels répertoriés ci-après. Ils sont utilisés dans des expressions booléennes.

Opérateur Description
< Inférieur à
<= Inférieur ou égal à
> Supérieur à
>= Supérieur ou égal à
= Egal à
<> Non égal à

Remarque : Les opérateurs relationnels répertoriés ci-dessus n'effectuent pas la distinction entre les majuscules et les minuscules lors de la comparaison de deux chaînes. L'expression suivante est donc TRUE :

'F:\MYFILE' = 'f:\myfile' 

Opérateurs effectuant la distinction majuscules/minuscules

Les opérateurs suivants permettent d'effectuer des comparaisons dans lesquelles la distinction entre les majuscules et les minuscules est prise en compte.

Opérateur Description
<< Inférieur à
<<== Inférieur ou égal à
>> Supérieur à
>>== Supérieur ou égal à
== Egal à
<<>> Non égal à

Pour un exemple, reportez-vous à la remarque de la page.

Expressions de la date

Considérée également comme un type de données simple, une valeur de date utilise une structure invisible qui vous permet d'obtenir des valeurs de mois, de jour et d'année. Utilisez une notation à point comme l'illustre l'exemple suivant.

dayValue := $Today.day;
monthValue := $Today.month;
yearValue := $Today.year;
(* $Today correspond à la date système*) 

Cet exemple montre que les expressions de date peuvent être suivies d'un point et de l'un des mots clés (day, month, ou year) qui permettent d'accéder à la valeur correspondante de la date. Dans l'exemple précédent, dayValue, monthValue, et yearValue correspondent à des variables de nombres entiers.

Modification des variables de date

Vous pouvez modifier la valeur du mois, du jour ou de l'année d'une variable de date, comme l'illustre l'exemple suivant :

d := $Today;
d.year := d.year + 1; 

Dans cet exemple, la variable de date d présente la valeur de la date système en cours. Une année est ajouté à l'année définie pour d.

La boîte à outils du développeur protège les utilisateurs contre toute date non valide. Dans l'exemple suivant, la variable de date utilise la valeur "2/1/1999" (et non "1/32/1999"):

d := {1,31,1999}: DATE; 
d.day := d.day + 1; 

Calcul du délai entre deux dates

La boîte à outils du développeur fournit une fonction DateDif qui permet de calculer le délai entre deux dates en mois, jours et années.

DateDif requiert trois arguments :

Par exemple :

    age := DateDif($Today,birthDate,$Years);


Expressions de l'heure

La boîte à outils du développeur fournit plusieurs fonctions qui vous permettent de manipuler des expressions d'heures. Comme les dates, les heures présentent plusieurs valeurs : heure, minute et seconde.

Vous pouvez utiliser une notation à point (également utilisée dans les dates) pour accéder aux différents éléments constitutifs d'une heure :

currentHour   := $Now.hour;
currentMinute := $Now.minute;
currentSecond := $Now.second;
(* $Now correspond à l'heure système*)

Modification des variables d'heure

Vous pouvez également modifier un élément donné d'une variable d'heure :

t      := $Now;
t.hour := t.hour + 3; 

La valeur d'heure t comporte la valeur de l'heure dans trois heures. Les valeurs d'heure présentent un format sur 24 heures afin de pouvoir faire la distinction entre midi et minuit. Le résultat de l'exemple suivant est t présentant la valeur {1,0,0}:TIME ou 1 A.M.:

t := {23,0,0}: TIME; 
t.hour := t.hour + 2; 

Calcul du délai entre deux heures

La boîte à outils du développeur fournit une fonction TimeDif qui permet de calculer le délai entre deux heures. L'exemple suivant montre le calcul du délai entre l'heure en cours et une heure de début antérieure startTime en heures, minutes et secondes :

hoursDiff := TimeDif($Now,startTime,$Hours);
minutesDiff := TimeDif($Now,startTime,$Minutes);
secondsDiff := TimeDif($Now,startTime,$Seconds); 

Tableaux

Un tableau correspond à une liste de valeurs de données de même type. Il s'agit également d'un type de données structuré. Les types de données structurés permettent d'effectuer des opérations spécifiques sur les données.

Un élément (valeur de données) d'un tableau peut être désigné par une expression constituée du nom du tableau suivi d'une expression d'index. Les éléments d'un tableau sont séquentiels ; le premier élément commence par un (1). Pour accéder à un élément donné, la valeur ou l'indice de cet élément est utilisé.

Dans l'exemple suivant, chaque indice figure entre crochets :

VARIABLES
  name[10]: ARRAY OF String;
ACTIONS
  name[1] := 'Tom';
  name[2] := 'Dick';
  name[3] := 'Harry'; 

Dans cet exemple, name correspond à un tableau de chaînes. La variable name peut contenir jusqu'à dix chaînes dans des éléments numérotés de 1 à 10.

Accès à des tableaux

L'accès aux tableaux s'effectue généralement à l'aide de variables. L'exemple ci-après montre comment la variable de nombre entier i est utilisée pour accéder à un élément de tableau donné, en enregistrant les dix valeurs du tableau name dans un fichier.

FOR i := 1 TO 10 DO
  FWriteLN(outputFile,name[i]);
  END; 

Toute tentative d'accès à un élément de tableau hors des limites définies pour ce tableau entraîne l'émission d'un message d'erreur d'exécution. Les deux instructions suivantes entraînent l'émission d'un message d'erreur :

name[-1] := 'Dick';
name[45] := 'Harry';

Chaînes traitées en tant que tableaux

Les chaînes peuvent être traitées comme des tables de caractères. A la fin de l'exemple de code suivant, la variable s prend la valeur G:\EADVISOR\ADVISOR\DATA.

VARIABLES
  s : STRING;
ACTIONS
  s := 'F:\EADVISOR\ADVISOR\DATA';
  s[1] := 'G'; 

Redimensionnement des tableaux

Les tableaux de la boîte à outils du développeur peuvent être redimensionnés de façon dynamique. Vous pouvez en modifier les dimensions au moment de l'exécution. L'instruction SetArrayLength permet d'effectuer ces redimensionnements. Par exemple,

SetArrayLength(name,100);

permet d'ajouter 90 nouveaux éléments au tableau pour lequel 10 emplacements ont déjà été déclarés. Aucune information contenue dans les 10 premiers emplacements ne sera affectée. Vous pouvez également réduire la taille d'un tableau comme le montre l'exemple suivant :

SetArrayLength(name,5); 

Dans ce cas, toutes les valeurs figurant dans les emplacements 6 à 10 seront perdues.

Listes

De même que le tableau, une liste de la boîte à outils du développeur correspond à un type de données structuré qui peut comporter plusieurs valeurs de même type. Les listes peuvent également être indexées avec des nombres entiers figurant entre crochets.

Avantages présentés par la liste

Dans la boîte à outils du développeur, vous n'avez pas besoin de posséder d'adresse, ni d'allouer ou désallouer de la mémoire pour créer des structures complètes liées aux listes. Il est plus facile de modifier les dimensions d'une liste que celles d'un tableau. Vous pouvez également insérer une nouvelle valeur au milieu d'une liste, alors que cette opération est plus délicate dans un tableau.

Utilisation des listes

L'exemple suivant montre comment déclarer et utiliser des listes :

VARIABLES
  name: List of String;
ACTIONS
  ListInsert(name,'Tom');
  ListInsert(name,'Dick');
  ListInsert(name,'Harry'); 

A la fin de cet exemple de code, la variable name correspond à une liste contenant trois valeurs : 'Tom', 'Dick' et 'Harry'.

Pointeurs de liste

Toutes les listes comportent un pointeur qui indique l'élément en cours d'une liste. Il s'agit du pointeur de liste. Lorsqu'un nouvel élément est ajouté à une liste, le pointeur de liste désigne cet élément. A la fin de l'exemple précédent, le pointeur désigne 'Harry'.

L'exemple suivant montre comment insérer un nouvel élément au milieu de la liste.

ListSetPos(name,1);
ListInsert(name,'Ellen'); 

Name comporte maintenant quatre valeurs : 'Tom,' 'Ellen,' 'Dick,' et 'Harry'.

Remarque : 'Ellen' est en deuxième position car l'instruction $ListInsert utilise $After par défaut. Le pointeur de liste désigne 'Ellen.' ListSetPos permet de positionner le pointeur de liste sur un élément donné.

Autres fonctions de liste

La boîte à outils du développeur présente d'autres fonctions qui vous permettent de manipuler des listes.

Fonction Description
ListDelete Supprime un élément d'une liste. (ListDelete(name,2) permet de supprimer 'Ellen' de l'exemple précédent).
ListLength Renvoie le nombre d'éléments figurant dans la liste.
ListNext Positionne le pointeur sur l'élément suivant de la liste.
ListPrev Positionne le pointeur sur l'élément précédent de la liste.
ListPos Renvoie l'indice de l'élément en cours.
ListFind Parcourt la liste à la recherche d'une valeur donnée et renvoie la valeur TRUE lorsque celle-ci est trouvée. La pointeur de liste se positionne sur la valeur en question. Par exemple, ListFind(name,'Dick') renvoie la valeur TRUE et positionne le pointeur sur 'Dick.'
ListSort Trie la liste dans l'ordre croissant.
ListPush Ajoute un nouvel élément au début de la liste.
ListPop Supprime le premier élément de la liste et le renvoie.

Etant donné que les listes peuvent être indexées comme des tableaux, l'instruction

s:= name[1];

permet d'affecter la valeur 'Tom' à la variable s.

Boucles FOR

La boîte à outils du développeur fournit une construction en boucle particulière pour les listes. L'instruction FOR permet de répéter des opérations sur toutes les valeurs d'une liste. Les instructions imbriquées dans le fragment FOR...END sont exécutées pour chaque élément de la liste. Le pointeur de liste désigne toujours le premier numéro de la liste. L'élément en cours de la liste est augmenté de 1 à chaque passage de la boucle.

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

FOR name DO
  FWriteLN(outputFile,name[$Current]);
  END; 

Constantes de liste particulières

L'exemple précédent illustre également l'utilisation d'une constante particulière appelée $Current. Elle peut être utilisée pour accéder aux éléments en cours d'une liste. Autres constantes de liste :

Ces constantes permettent d'accéder respectivement au premier et au dernier élément d'une liste. Par exemple, les lignes

FWriteLN(outputFile,name[$First]);
FWriteLN(outputFile,name[$Last]); 

renvoient "Tom" et "Harry" dans le fichier de sortie.

Sélection dans la liste

De nombreuses instructions de la boîte à outils du développeur supportent la "sélection" automatique dans la liste : les instructions acceptent un seul élément d'un type donné ou d'une liste d'éléments.

Si vous exécutez une instruction pour une liste, cette instruction s'applique à tous les éléments de la liste concernée. Ce type d'instruction est désigné par le terme d'instruction avec boucle FOR implicite.

WinWriteLN constitue un exemple de ce type d'instruction :

WinWriteLN(myWindow,name); 

Cette instruction permet d'afficher toutes les valeurs de la variable name dans la fenêtre désignée par myWindow. Plusieurs instructions Window et SQL supportent la sélection dans la liste.

Enregistrements

A la différence des tableaux et des listes qui peuvent contenir plusieurs valeurs d'un même type, un enregistrement peut contenir plusieurs valeurs de types différents.

Déclaration d'une variable d'enregistrement

La déclaration d'une variable de type enregistrement s'effectue en deux étapes :

Remarque : Lorsque vous déclarez une variable de type d'enregistrement, vous étendez le langage de la boîte à outils du développeur à votre propre type de données.

Exemple de code de variable

Examinez l'exemple de code suivant :

TYPES
EmployeeRecord IS RECORD 
      first_name, last_name: String; 
      age : Integer;
      salary : Real;
      married : Boolean;
      hireDate : Date;
      startTime, stopTime : Time;
  END;
VARIABLES
  employee: EmployeeRecord; 

Cet exemple illustre la déclaration d'un nouveau type d'enregistrement nommé EmployeeRecord. Cet enregistrement comporte huit zones, chacune d'elles correspondant à un type de données simple.

Référence à des zones de variable

Comme pour les dates et les heures, vous pouvez utiliser une notation (à point) <variable>.<zone> pour faire référence aux zones d'un enregistrement.
Par exemple, les lignes suivantes permettent d'initialiser la variable "employee" déclarée précédemment :

employee.first_name := 'Calbert';
employee.last_name  := 'Chaney';
employee.age        := 21;
employee.salary     := 2500000.0;
employee.married    := FALSE;
employee.hireDate   := {2,15,1993}: DATE;
employee.startTime  := {8,30,0}: TIME;
employee.stopTime   := {17,30,0}: TIME; 

Affectation de variables compatibles

Les variables d'un même type d'enregistrement peuvent être affectées d'une valeur. Si vous avez déclaré une variable employee2 de type EmployeeRecord, l'ajout de l'instruction ci-après se répercute sur toutes les zones de la variable employee copiée dans la variable employee2 :

employee2 := employee; 

Vous pouvez également créer des listes et des tableaux d'enregistrements :

employeeList: List Of EmployeeRecord; 

Une déclaration d'enregistrement peut comporter des tableaux, des listes et d'autres enregistrements. Par exemple, la déclaration de EmployeeRecord peut être modifiée de la façon suivante :

EmployeeRecord IS RECORD
      first_name, last_name: String;
      age : Integer;
      salary : Real;
      married : Boolean;
      hireDate : Date;
      startTime, stopTime : Time;
      manages : List of String;
  END; 

La valeur de manages peut être utilisée afin de conserver la trace des noms des employés sous la responsabilité d'un employé donné.

Instructions d'entrée et de sortie

La boîte à outils du développeur présente plusieurs instructions qui permettent d'effectuer des entrées et des sorties d'enregistrements de base de données.

Par exemple, l'instruction suivante peut être utilisée pour charger une ligne du tableau EMPLOYEES dans la variable employee déclarée précédemment :

SQLSelectInto('SELECT * FROM EMPLOYEES WHERE
    EMPLOYEE_ID=105',employee); 

La boîte à outils du développeur :

La boîte à outils du développeur vous permet également de mapper les zones d'un enregistrement vers un formulaire. Lorsque l'utilisateur appuie sur la touche Entrée après avoir rempli un formulaire, les informations affichées à l'écran sont sauvegardées dans des zones correspondantes dans l'enregistrement qui peut être examiné et manipulé.

Types de données définis par l'utilisateur

Outre les enregistrements, vous pouvez créer d'autres types définis par l'utilisateur. Un type défini par l'utilisateur est un type de données défini dans un programme. Il est généralement constitué d'une combinaison de types de données. Les types définis par l'utilisateur sont souvent exploités pour créer des structures de données.

Toute combinaison de listes, de tableaux, d'enregistrements et de types de données simples utilisée dans une déclaration de variable peut se voir attribuer un nom réutilisable dans la déclaration du type de données. Par exemple, vous pouvez définir un nouveau type de données comme le montre l'exemple suivant :

TYPES
StringList = LIST OF STRING; 

Une fois la déclaration effectuée, vous pouvez faire appel à StringList pour déclarer des variables, plutôt que LIST OF STRING.

Compatibilité d'affectation

Les règles suivantes portent sur la compatibilité d'affectation de types de données structurés définis par l'utilisateur.

Lors de la vérification de la compatibilité d'affectation entre deux variables ou expressions, la boîte à outils du développeur vérifie uniquement si les noms des types correspondent. Elle ne vérifie pas si les déclarations d'enregistrements sont identiques.

Initialisation de variables

L'initialisation d'une variable déclarée correspond à l'affectation d'une valeur initiale à cette variable. La boîte à outils du développeur vous permet d'initialiser des variables lorsqu'elles sont déclarées, comme le montre l'exemple suivant :

VARIABLES
 i {1}                                : INTEGER;
 s {'F:\MYFILE'}                      : STRING;
 d {2,11,1956}                        : DATE;
 l {'Thomas','Didier','Henri'}             : LIST OF STRING;
 r {'Steve','Wantz',32,189000.00,TRUE,
   {3,30,1986}                        : DATE, 
   {6,30,0}                           : TIME,
   {4,30,0}                           : TIME,
   {'Thomas','Didier','Henri'} : LIST OF STRING :
    EmployeeRecord; 

Conventions relatives aux variables

De manière générale, un nom de variable est suivi :

Vous pouvez également initialiser des variables de types structurés comme des listes, des tableaux et des enregistrements, de la même manière.

Notez que la valeur d'initialisation est associée à la variable et non au type. Dans la ligne,

VARIABLES
  i, j {27}: INTEGER; 

seule la variable j est initialisée. La variable i ne l'est pas. Chaque variable doit être initialisée séparément.

Valeur $Unknown

Toutes les variables non initialisées dans la boîte à outils du développeur commencent par une valeur $Unknown, contrairement aux langages C et Pascal pour lesquels ces variables commencent par des valeurs aléatoires.

L'initialisation de toutes les variables à 0, à 1 ou à une chaîne vide permet d'éviter les erreurs les plus courantes. Dans l'exemple suivant :

newSalary := oldSalary*1.05; 

la variable oldSalary n'a pas été initialisée à une autre valeur que $Unknown Par conséquent, une erreur se produira lors de l'exécution car 1.05 sera multiplié par $Unknown.


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

Retour à la table des matières

Copyright