Tivoli Service Desk 6.0 Developer's Toolkit - Guide de programmation TSD Script
Retour à la table des matières
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.
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 :
La boîte à outils du développeur présente six types de données simples.
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 :
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 :
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 :
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.
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.
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.
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;
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;
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.
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.
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.
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;
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.
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 :
Les instructions et les opérateurs de manipulation de chaîne sont répertoriés dans la liste suivante :
s1 := 'F:\CODE'; s2 := 'PROGRAM.EXE'; s3 := s1 & '\' & s2;
Dans cet exemple, la variable s3 comporte la chaîne F:\CODE\PROGRAM.EXE.' Les variables s1 et s2 n'ont absolument pas été modifiées. Elles conservent leur valeur d'origine. La perluète permet de concaténer tout nombre de constantes, de variables et d'expressions pour former une nouvelle chaîne. Elle convertit également automatiquement en chaînes des valeurs qui ne correspondent pas à des chaînes, avant d'effectuer la concaténation. Par exemple :
s1 := 'La date est ' & $Today & 'et l'heure est ' & $Now;
Dans cet exemple, les constantes de la boîte à outils du développeur $Today (date système) et $Now (heure système) sont automatiquement converties en chaînes afin de pouvoir être concaténées.
s := 'LIB(ase) FILE(qrpgsrc); s := StrUpper(s); (* now s = 'LIB(ASE) FILE(QRPGSRC) *)
Remarque : Pour les utilisateurs internationaux, la boîte à outils du développeur suit les règles de majuscules relatives à l'environnement local. Par exemple, "éclair" devient "ECLAIR" en France et dans les régions francophones du Canada.
s := 'LIB(ase) FILE(qrpgsrc); s := StrLower(s); (* now s = 'lib(ase) file(qrpgsrc) *)
Remarque : Pour les utilisateurs internationaux, la boîte à outils du développeur suit les règles de majuscules relatives à l'environnement local du poste de travail.
~ La variable de chaîne dans laquelle la nouvelle chaîne est insérée
~ La chaîne qui est insérée
~ L'indice du paramètre de chaîne au niveau duquel la nouvelle chaîne doit être insérée
Par exemple :
s := StrInsert('LIB(ASE) MBR(MYPROG)', 'FILE(QRPGSRC) ',10); (* now s = 'LIB(ASE) FILE(QRPGSRC) MBR(MYPROG) *)
Remarque : Les utilisateurs internationaux qui écrivent du code pour plusieurs environnements locaux doivent éviter d'"assembler" des fragments d'éléments différents. Les genres et les règles d'accord qui s'y rapportant, présents dans de nombreuses langues ne sont pas respectés lorsque des fragments sont assemblés de cette manière.
~ Le nom d'un paramètre de chaîne
~ Un indice de départ
~ Le nombre de caractères à supprimer
Par exemple :
s := StrDelete('LIB(ASE) FILE(QRPGSRC) MBR(MYPROG)',10,14); (* now s = 'LIB(ASE) MBR(MYPROG)' *)
~ Le nom de la chaîne source
~ L'index de départ dans la chaîne source
~ Le nombre de caractères à copier
Par exemple :
fileName := 'LIB(ASE) FILE(QRPGSRC) MBR(MYPROG)'; s := StrCopy(fileName,15,7); (* now S = 'QRPGSRC' *)
Remarque : La recherche StrPos ne respecte pas la distinction entre les majuscules et les minuscules. La première position est toujours indexée sur le chiffre 1 plutôt que 0, comme c'est le cas dans le langage C et d'autres langages de programmation.
Si la seconde chaîne est introuvable, la valeur "0" est renvoyée. Par exemple :
company := 'Tivoli Systems'; loc := StrPos(company, 'Sys'); (*loc = 8*)
La variable loc présente la valeur 8 après exécution de ce code.
Par exemple :
IF StrMatch(s,'*.BAK') THEN FErase(s); END;
La boîte à outils du développeur fournit d'autres instructions de manipulation de chaînes, notamment StrToken, StrTrim, StrLTrim et StrLength.
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)
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 | - | - |
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 :
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'
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.
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.
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;
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);
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*)
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;
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);
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.
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';
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';
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.
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.
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.
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'.
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é.
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.
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;
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.
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.
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.
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.
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.
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;
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é.
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é.
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.
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.
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;
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.
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