Langage
(→while) |
|||
(15 révisions intermédiaires par un utilisateur sont masquées) | |||
Ligne 1 : | Ligne 1 : | ||
− | == | + | ==Introduction== |
− | + | Le langage 1000 est un langage managé dont la syntaxe hérite du Pascal Objet. | |
− | + | Les différences principales avec le Pascal Objet sont les suivantes : | |
− | * | + | *Il n'y a pas de support pour définir des types, classes et structures. Dans la méthodologie de développement d’une application ligne 1000 cette partie est faite dans le Modèle Métier. |
− | + | ||
− | == | + | *La mémoire est managée de sorte qu’il n’est pas nécessaire d’allouer ou de libérer explicitement la mémoire. |
− | === | + | |
− | + | *Il n'y a pas de support pour les types ensembles (SET) et les opérateurs associés. | |
+ | |||
+ | ==Le langage== | ||
+ | ===Bloc de code=== | ||
+ | Un bloc de code à la structure suivante : | ||
<pre> | <pre> | ||
− | declarations ; | + | var |
+ | declarations ; | ||
begin | begin | ||
instructions ; | instructions ; | ||
Ligne 18 : | Ligne 22 : | ||
</pre> | </pre> | ||
− | + | La partie déclaration peut contenir des déclarations de variables ou des procédures imbriquées. | |
===Variables=== | ===Variables=== | ||
− | + | Les variables DOIVENT être explicitement déclarées en utilisant la syntaxe suivante : | |
<pre> | <pre> | ||
Ligne 30 : | Ligne 34 : | ||
identifier : Array of type; | identifier : Array of type; | ||
</pre> | </pre> | ||
+ | |||
===Types=== | ===Types=== | ||
− | + | Le langage supporte des déclarations de type fort et contrôle l'intégrité des types; toutefois, pour des raisons de compatibilité ascendante, les erreurs de contrôle de type génèrent des messages d'alerte et pas des erreurs. | |
{| class="wikitable" | {| class="wikitable" | ||
Ligne 41 : | Ligne 46 : | ||
|integer | |integer | ||
|int,unsigned,short,long,unsignedlong | |int,unsigned,short,long,unsignedlong | ||
− | |32 bit | + | |Entier 32 bit signé |
|- | |- | ||
|longint | |longint | ||
| | | | ||
− | |64 bit | + | |Entier 64 bit signé |
|- | |- | ||
|double | |double | ||
− | |float | + | |float (***) |
− | |double | + | |Nombre flottant double précision |
+ | * 5.0e-324 .. 1.7e+308 | ||
+ | * 15-16 chiffres significatifs | ||
|- | |- | ||
|currency | |currency | ||
|decimal | |decimal | ||
− | | | + | |Valeur monétaire virgule fixe à 4 décimales |
+ | * -922337203685477.5808.. 922337203685477.5807 | ||
+ | * 10-20 chiffres significatifs | ||
|- | |- | ||
|boolean | |boolean | ||
| | | | ||
− | | | + | |Valeur logique vrai ou fausse |
|- | |- | ||
|string | |string | ||
|anyURI | |anyURI | ||
− | | | + | |Chaîne de caractère (**) |
|- | |- | ||
|char | |char | ||
| | | | ||
− | | | + | |Caractère |
|- | |- | ||
|enum | |enum | ||
| | | | ||
− | | | + | |Enumération |
|- | |- | ||
|TDatetime | |TDatetime | ||
|datetime | |datetime | ||
− | |Date | + | |Date et heure encodée en double |
|- | |- | ||
|date | |date | ||
| | | | ||
− | |Date | + | |Date encodée en double |
|- | |- | ||
|time | |time | ||
| | | | ||
− | | | + | |Heure encodée en double |
|- | |- | ||
|variant | |variant | ||
| | | | ||
− | | | + | |Containeur de variable de type dynamique. |
|- | |- | ||
|TClass | |TClass | ||
| | | | ||
− | | | + | |Type classe générique |
|- | |- | ||
|TObject | |TObject | ||
| | | | ||
− | | | + | |Type objet générique |
|- | |- | ||
|TPersistent | |TPersistent | ||
| | | | ||
− | | | + | |Type persistent générique |
|} | |} | ||
− | (*) | + | (*) Les alias sont définis pour supporter les sérialisation SOAP |
− | (**) | + | (**) L'encodage des chaînes de caractère peut dépendre des versions; jusqu'à la version 5.60 incluse les chaînes sont basées sur un encodage ANSI. Dans le futur les chaînes pourraient être basées sur un encodage unicode. |
− | + | (***) Le type Double (Float) n'est pas adéquat pour réaliser des calculs monétaires, utiliser le type Currency | |
+ | |||
+ | Les types suivants sont spécifiquement introduis pour le support de la sérialisation SOAP : | ||
{| class="wikitable" | {| class="wikitable" | ||
Ligne 132 : | Ligne 143 : | ||
|} | |} | ||
− | === | + | ===Constantes=== |
− | + | Il n'y a pas de support pour déclarer des constantes. | |
− | + | ||
{| class="wikitable" | {| class="wikitable" | ||
Ligne 156 : | Ligne 166 : | ||
| 'This is a string with a '' quote' | | 'This is a string with a '' quote' | ||
|} | |} | ||
− | ===Procedures | + | ===Procedures et fonctions=== |
− | + | Tout comme en langage Pascal les procédures et fonctions peuvent être imbriquées dans un bloc de code : | |
<pre> | <pre> | ||
Ligne 175 : | Ligne 185 : | ||
</pre> | </pre> | ||
− | == | + | ==Opérateurs== |
− | === | + | ===Arithmétiques=== |
{| class="wikitable" | {| class="wikitable" | ||
|- | |- | ||
Ligne 201 : | Ligne 211 : | ||
|} | |} | ||
− | === | + | ===Logiques=== |
{| class="wikitable" | {| class="wikitable" | ||
|- | |- | ||
Ligne 217 : | Ligne 227 : | ||
|} | |} | ||
− | === | + | ===Comparaisons=== |
{| class="wikitable" | {| class="wikitable" | ||
|- | |- | ||
Ligne 240 : | Ligne 250 : | ||
==Expression== | ==Expression== | ||
− | + | Les expressions sont évaluées de la gauche vers la droite, les termes doivent être placés entre parenthèses : | |
<pre> | <pre> | ||
Ligne 246 : | Ligne 256 : | ||
</pre> | </pre> | ||
− | + | L'évaluation des expressions est optimisée : | |
<pre> | <pre> | ||
Ligne 257 : | Ligne 267 : | ||
==Instructions== | ==Instructions== | ||
− | === | + | ===Instruction=== |
− | + | Les instruction doivent être séparées par un point virgule ";" | |
<pre> | <pre> | ||
Ligne 266 : | Ligne 276 : | ||
</pre> | </pre> | ||
− | + | Plusieurs instructions peuvent être assemblées en utilisant begin / end : | |
<pre> | <pre> | ||
Ligne 276 : | Ligne 286 : | ||
</pre> | </pre> | ||
− | === | + | ===Affectation=== |
− | + | L'affectation utilise l'opérateur ":=" : | |
<pre> | <pre> | ||
Ligne 284 : | Ligne 294 : | ||
===for=== | ===for=== | ||
− | + | L'instruction for permet l'implémentation de boucle basées sur un index : | |
<pre> | <pre> | ||
Ligne 294 : | Ligne 304 : | ||
</pre> | </pre> | ||
− | + | La variable d'index DOIT être une variable entière. | |
===while=== | ===while=== | ||
− | + | L'instruction while permet l'implémentation de boucle basées sur une expression : | |
<pre> | <pre> | ||
Ligne 303 : | Ligne 313 : | ||
statement ; | statement ; | ||
</pre> | </pre> | ||
+ | |||
+ | Le corps de la boucle peut ne pas être exécuté. | ||
===repeat=== | ===repeat=== | ||
− | + | L'instruction repeat permet l'implémentation de boucle basées sur une expression : | |
<pre> | <pre> | ||
Ligne 313 : | Ligne 325 : | ||
</pre> | </pre> | ||
− | + | Le corps de la boucle sera au moins exécuté une fois. | |
===foreach=== | ===foreach=== | ||
− | + | L'instruction foreach permet l'itération à l'intérieur d'une collection : | |
<pre> | <pre> | ||
foreach V in C do | foreach V in C do | ||
+ | statement ; | ||
+ | |||
+ | foreach V in C index I do | ||
statement ; | statement ; | ||
</pre> | </pre> | ||
− | C | + | C DOIT être une [[:category:Objets itérateurs|collection]] (ex : liste, curseur) |
− | V | + | V DOIT être une variable du type de la collection. |
+ | |||
+ | Optionnellement une variable d'index I peut être utilisée, dans ce cas elle DOIT être une variable entière. | ||
===break=== | ===break=== | ||
− | + | L'instruction break permet d'interrompre l'exécution d'une boucle : | |
<pre> | <pre> | ||
Ligne 337 : | Ligne 354 : | ||
</pre> | </pre> | ||
− | + | L'effet de l'instruction break est de sortir de la boucle. | |
− | + | L'instruction break peut être utilisée dans les boucles for,foreach,while,repeat. | |
===continue=== | ===continue=== | ||
− | + | L'instruction continue permet d'interrompre l'exécution du corps de boucle et de passer à l'itération suivante : | |
<pre> | <pre> | ||
Ligne 352 : | Ligne 369 : | ||
</pre> | </pre> | ||
− | + | L'effet de l'instruction continue est de passer à l'itération suivante. | |
− | + | L'instruction continue peut être utilisée dans les boucles for,foreach,while,repeat. | |
===if=== | ===if=== | ||
− | + | L'instruction if permet de réaliser un branchement en fonction d'un test : | |
<pre> | <pre> | ||
Ligne 366 : | Ligne 383 : | ||
===case=== | ===case=== | ||
− | + | L'instruction case permet un branchement en fonction de la valeur d'une variable. | |
− | |||
− | |||
− | |||
− | |||
− | |||
<pre> | <pre> | ||
− | + | case V of | |
+ | const1 : statement1; | ||
+ | const2 : statement2; | ||
+ | ... | ||
+ | else statementN; | ||
+ | end; | ||
</pre> | </pre> | ||
− | + | La variable peut être une variable de type entière ou chaîne de caractère. | |
− | + | ===Support des exceptions=== | |
+ | Une exception peut être levée par le code managé, la librairie d'exécution ou le framework. Dans tous les cas les exceptions peuvent être traitées par des blocs try finally / except. | ||
− | ==== | + | ====Lever une exception==== |
+ | L'instruction raise permet de lever une exception : | ||
+ | |||
+ | <pre> | ||
+ | raise ERule.Create('some message here'); | ||
+ | </pre> | ||
+ | |||
+ | La classe de l'exception doit être une des classes suivantes : | ||
+ | |||
+ | {| class="wikitable" | ||
+ | |- | ||
+ | |ERule | ||
+ | |Erreur métier | ||
+ | |} | ||
− | + | ====Try / finally==== | |
+ | Un bloc d'instruction Try / finally permet d'intercepter une exception en vu d'assurer l'exécution d'un code de sortie : | ||
<pre> | <pre> | ||
Ligne 394 : | Ligne 426 : | ||
</pre> | </pre> | ||
− | + | Si une exception est levée dans le bloc 1 l'exécution se poursuit dans le bloc 2 avant de revenir au bloc supérieur. Le bloc 3 n'est jamais exécuté. | |
====Try / except block==== | ====Try / except block==== | ||
− | + | Un bloc d'instruction Try / except permet d'intercepter une exception en vu de traiter l'erreur : | |
<pre> | <pre> | ||
Ligne 408 : | Ligne 440 : | ||
</pre> | </pre> | ||
− | + | Si une exception est levée dans le bloc 1 l'exécution se poursuit dans le bloc 2 puis dans le bloc 3. | |
− | + | L'objet d'exception E peut être manipulé dans le bloc d'exception : | |
<pre> | <pre> | ||
Ligne 416 : | Ligne 448 : | ||
statement 1; | statement 1; | ||
except | except | ||
− | + | showMessage(E.Message); | |
− | + | statement 2; | |
− | + | ||
− | + | ||
− | + | ||
end; | end; | ||
statement 3; | statement 3; | ||
</pre> | </pre> | ||
− | + | L'exception peut être de nouveau levée a l'intérieur d'un bloc d'exception : | |
<pre> | <pre> | ||
Ligne 437 : | Ligne 466 : | ||
</pre> | </pre> | ||
− | + | Si une exception est levée dans le bloc 1 l'exécution se poursuit dans le bloc 2 puis est redéclenchée; le bloc 3 n'est pas exécuté. | |
− | == | + | ==Fonctions magiques== |
===Assign()=== | ===Assign()=== | ||
− | + | La fonction Assign() permet de tester qu'une variable contenant un objet est affecté, c'est à dire que la référence de l'objet n'est pas nil. | |
− | == | + | Exemple : |
− | === | + | <source lang='delphi'> |
− | === | + | begin |
− | ==== | + | // Teste le retour d'une fonction |
− | === | + | inst := someFunctionWichReturnAnObject(...); |
− | === | + | if Assigned(inst) then |
+ | begin | ||
+ | end; | ||
+ | end; | ||
+ | |||
+ | begin | ||
+ | // Teste si une référence est affectée | ||
+ | if Assigned(Ref1) and Assigned(Ref1.Ref2) and Assigned(Ref1.Ref2.Ref3) then | ||
+ | begin | ||
+ | V := Ref1.Ref2.Ref3.Attribute; | ||
+ | end; | ||
+ | end; | ||
+ | </source> | ||
+ | |||
+ | A partir de la version 5.60 il est possible de tester directement une notation pointée : | ||
+ | |||
+ | <source lang='delphi'> | ||
+ | begin | ||
+ | // Teste si une référence est affectée (safe in 5.60) | ||
+ | if Assigned(Ref1.Ref2.Ref3) then | ||
+ | begin | ||
+ | V := Ref1.Ref2.Ref3.Attribute; | ||
+ | end; | ||
+ | end; | ||
+ | </source> | ||
+ | |||
+ | ===_TP()=== | ||
+ | La fonction _TP() permet de convertir une chaîne de caractère dans la langue utilisée lors de l'exécution. | ||
+ | |||
+ | Cette fonction à deux usages : | ||
+ | # Elle permet aux outils de traduction de retrouver les chaînes de caractère à traduire. | ||
+ | # Elle traduit les chaînes de caractère dans la langue utilisée lors de l'exécution. | ||
+ | |||
+ | Le développeur doit respecter certaine règles pour permettre une traduction efficace: | ||
+ | |||
+ | '''Ne pas utiliser de variable dans les messages :''' | ||
+ | <source lang='delphi'> | ||
+ | begin | ||
+ | // Message impossible à extraire (Erreur de compilation) : | ||
+ | AMsg := _TP('L''objet '+inst.Caption+' ne remplit pas la condition ... '); | ||
+ | |||
+ | // Forme correcte : | ||
+ | AMsg := Format(_TP('L''objet %s ne remplit pas la condition ...'),[inst.Caption]); | ||
+ | end; | ||
+ | </source> | ||
+ | |||
+ | '''Ne pas couper les messages en morceaux incompréhensibles :''' | ||
+ | <source lang='delphi'> | ||
+ | begin | ||
+ | // Message incompréhensible pour le traducteur : | ||
+ | AMsg := _TP('L'objet') +inst.Caption+ _TP(' ne remplit pas la condition'); | ||
+ | end; | ||
+ | </source> | ||
+ | |||
+ | '''Gérer l'ordre des paramètres dans les formats :''' | ||
+ | <source lang='delphi'> | ||
+ | begin | ||
+ | // L'ordre des paramètres pourra être inversé dans le message traduit. | ||
+ | AMsg := Format(_TP('L''objet %1s ne remplit pas la condition exprimée par %2s'),[inst.Caption,AExpression]); | ||
+ | end; | ||
+ | </source> | ||
+ | |||
+ | Voir aussi : | ||
+ | |||
+ | * [[Guide de la traduction|Traduction]] | ||
+ | * [[:Category:RTL Traduction|Fonctions de traduction]] | ||
+ | |||
+ | ===AS=== | ||
+ | '''AS''' est un opérateur de transtypage utilisable sur les classes métiers. | ||
+ | |||
+ | L'opérateur AS est évaluée à la compilation pour permettre au compilateur de connaître la classe de l'objet transtypé '''ET''' à l'exécution pour vérifier que la classe de l'objet est bien conforme à celle indiquée dans le transtypage. | ||
+ | |||
+ | Exemple : | ||
+ | <source lang='delphi'> | ||
+ | function foo(inst:TitObject):Integer; | ||
+ | begin | ||
+ | // Si inst n'est pas un objet de MyClasse une exception sera levée. | ||
+ | Result := (inst as MyClasse).MyVariable; | ||
+ | end; | ||
+ | |||
+ | function foo(inst:TitObject):Integer; | ||
+ | var V:MyClasse; | ||
+ | begin | ||
+ | // Si inst n'est pas un objet de MyClasse une exception sera levée. | ||
+ | V := (inst as MyClasse); | ||
+ | Result := V.MyVariable; | ||
+ | end; | ||
+ | </source> | ||
+ | |||
+ | ===IS=== | ||
+ | '''IS''' est un opérateur boolean qui teste si un objet est d'une classe métier particulière. | ||
+ | |||
+ | Exemple: | ||
+ | <source lang='delphi'> | ||
+ | function foo(inst:TitObject):Integer; | ||
+ | begin | ||
+ | if (inst is MyClass) then | ||
+ | begin | ||
+ | ... | ||
+ | end | ||
+ | else | ||
+ | if (inst is OtherClass) then | ||
+ | begin | ||
+ | .... | ||
+ | end; | ||
+ | end; | ||
+ | </source> | ||
− | + | {{Footer}} | |
+ | [[category:DSM]] | ||
+ | [[category:Développement]] | ||
+ | [[category:Langage]] |
Version actuelle en date du 2 novembre 2023 à 07:07
Sommaire |
Introduction
Le langage 1000 est un langage managé dont la syntaxe hérite du Pascal Objet.
Les différences principales avec le Pascal Objet sont les suivantes :
- Il n'y a pas de support pour définir des types, classes et structures. Dans la méthodologie de développement d’une application ligne 1000 cette partie est faite dans le Modèle Métier.
- La mémoire est managée de sorte qu’il n’est pas nécessaire d’allouer ou de libérer explicitement la mémoire.
- Il n'y a pas de support pour les types ensembles (SET) et les opérateurs associés.
Le langage
Bloc de code
Un bloc de code à la structure suivante :
var declarations ; begin instructions ; end;
La partie déclaration peut contenir des déclarations de variables ou des procédures imbriquées.
Variables
Les variables DOIVENT être explicitement déclarées en utilisant la syntaxe suivante :
var identifier : type; identifier, identifier : type; identifier : Array[0..X] of type; identifier : Array of type;
Types
Le langage supporte des déclarations de type fort et contrôle l'intégrité des types; toutefois, pour des raisons de compatibilité ascendante, les erreurs de contrôle de type génèrent des messages d'alerte et pas des erreurs.
type | alias(*) | remarks |
---|---|---|
integer | int,unsigned,short,long,unsignedlong | Entier 32 bit signé |
longint | Entier 64 bit signé | |
double | float (***) | Nombre flottant double précision
|
currency | decimal | Valeur monétaire virgule fixe à 4 décimales
|
boolean | Valeur logique vrai ou fausse | |
string | anyURI | Chaîne de caractère (**) |
char | Caractère | |
enum | Enumération | |
TDatetime | datetime | Date et heure encodée en double |
date | Date encodée en double | |
time | Heure encodée en double | |
variant | Containeur de variable de type dynamique. | |
TClass | Type classe générique | |
TObject | Type objet générique | |
TPersistent | Type persistent générique |
(*) Les alias sont définis pour supporter les sérialisation SOAP
(**) L'encodage des chaînes de caractère peut dépendre des versions; jusqu'à la version 5.60 incluse les chaînes sont basées sur un encodage ANSI. Dans le futur les chaînes pourraient être basées sur un encodage unicode.
(***) Le type Double (Float) n'est pas adéquat pour réaliser des calculs monétaires, utiliser le type Currency
Les types suivants sont spécifiquement introduis pour le support de la sérialisation SOAP :
type | alias | remarks |
---|---|---|
normalizedString | ||
token | ||
duration | ||
base64binary | Binary base 64 encoded stream | |
hexbinary | Hexadecimal encoded stream |
Constantes
Il n'y a pas de support pour déclarer des constantes.
integer | 10 |
hexadecimal | $0A |
float | 1.00 |
char | 'A' |
char | #10 |
string | 'This is a string with a quote' |
Procedures et fonctions
Tout comme en langage Pascal les procédures et fonctions peuvent être imbriquées dans un bloc de code :
var p1,p2,p3 : type; function name(p4:type):type; var p2:type; begin Result := p1+p4+p2; end; begin ... p3 := name(p1,p2); end;
Opérateurs
Arithmétiques
+ | Addition |
- | Subtraction |
unary (-) | Negation |
/ | Division |
* | Multiplication |
div | Integer division |
mod | Integer modulo |
Logiques
and | logical AND |
or | logical OR |
xor | logical XOR |
not | Negation |
Comparaisons
= | equal |
<> | not equal |
> | upper |
>= | upper equal |
< | lower |
<= | lower equal |
Expression
Les expressions sont évaluées de la gauche vers la droite, les termes doivent être placés entre parenthèses :
(a=b) and (c=d) ....
L'évaluation des expressions est optimisée :
// term is not evaluate. false and term // term is not evaluate. true or term
Instructions
Instruction
Les instruction doivent être séparées par un point virgule ";"
x := 1; y := 2; x := x+y;
Plusieurs instructions peuvent être assemblées en utilisant begin / end :
begin x := 1; y := 2; x := x+y; end;
Affectation
L'affectation utilise l'opérateur ":=" :
x := 1;
for
L'instruction for permet l'implémentation de boucle basées sur un index :
for index:=lower to upper do statement ; for index:=upper downto lower do statement ;
La variable d'index DOIT être une variable entière.
while
L'instruction while permet l'implémentation de boucle basées sur une expression :
while (expression) do statement ;
Le corps de la boucle peut ne pas être exécuté.
repeat
L'instruction repeat permet l'implémentation de boucle basées sur une expression :
repeat statement ; until (expression)
Le corps de la boucle sera au moins exécuté une fois.
foreach
L'instruction foreach permet l'itération à l'intérieur d'une collection :
foreach V in C do statement ; foreach V in C index I do statement ;
C DOIT être une collection (ex : liste, curseur) V DOIT être une variable du type de la collection.
Optionnellement une variable d'index I peut être utilisée, dans ce cas elle DOIT être une variable entière.
break
L'instruction break permet d'interrompre l'exécution d'une boucle :
for index:=lower to upper do begin .... if expression then break; end;
L'effet de l'instruction break est de sortir de la boucle.
L'instruction break peut être utilisée dans les boucles for,foreach,while,repeat.
continue
L'instruction continue permet d'interrompre l'exécution du corps de boucle et de passer à l'itération suivante :
for index:=lower to upper do begin if expression then continue; .... end;
L'effet de l'instruction continue est de passer à l'itération suivante.
L'instruction continue peut être utilisée dans les boucles for,foreach,while,repeat.
if
L'instruction if permet de réaliser un branchement en fonction d'un test :
if expression then statement ; if expression then statement else statement ;
case
L'instruction case permet un branchement en fonction de la valeur d'une variable.
case V of const1 : statement1; const2 : statement2; ... else statementN; end;
La variable peut être une variable de type entière ou chaîne de caractère.
Support des exceptions
Une exception peut être levée par le code managé, la librairie d'exécution ou le framework. Dans tous les cas les exceptions peuvent être traitées par des blocs try finally / except.
Lever une exception
L'instruction raise permet de lever une exception :
raise ERule.Create('some message here');
La classe de l'exception doit être une des classes suivantes :
ERule | Erreur métier |
Try / finally
Un bloc d'instruction Try / finally permet d'intercepter une exception en vu d'assurer l'exécution d'un code de sortie :
try statement 1; finally statement 2; end; statement 3 ;
Si une exception est levée dans le bloc 1 l'exécution se poursuit dans le bloc 2 avant de revenir au bloc supérieur. Le bloc 3 n'est jamais exécuté.
Try / except block
Un bloc d'instruction Try / except permet d'intercepter une exception en vu de traiter l'erreur :
try statement 1; except statement 2; end; statement 3;
Si une exception est levée dans le bloc 1 l'exécution se poursuit dans le bloc 2 puis dans le bloc 3.
L'objet d'exception E peut être manipulé dans le bloc d'exception :
try statement 1; except showMessage(E.Message); statement 2; end; statement 3;
L'exception peut être de nouveau levée a l'intérieur d'un bloc d'exception :
try statement 1; except statement 2; raise ; end; statement 3;
Si une exception est levée dans le bloc 1 l'exécution se poursuit dans le bloc 2 puis est redéclenchée; le bloc 3 n'est pas exécuté.
Fonctions magiques
Assign()
La fonction Assign() permet de tester qu'une variable contenant un objet est affecté, c'est à dire que la référence de l'objet n'est pas nil.
Exemple :
begin // Teste le retour d'une fonction inst := someFunctionWichReturnAnObject(...); if Assigned(inst) then begin end; end; begin // Teste si une référence est affectée if Assigned(Ref1) and Assigned(Ref1.Ref2) and Assigned(Ref1.Ref2.Ref3) then begin V := Ref1.Ref2.Ref3.Attribute; end; end;
A partir de la version 5.60 il est possible de tester directement une notation pointée :
begin // Teste si une référence est affectée (safe in 5.60) if Assigned(Ref1.Ref2.Ref3) then begin V := Ref1.Ref2.Ref3.Attribute; end; end;
_TP()
La fonction _TP() permet de convertir une chaîne de caractère dans la langue utilisée lors de l'exécution.
Cette fonction à deux usages :
- Elle permet aux outils de traduction de retrouver les chaînes de caractère à traduire.
- Elle traduit les chaînes de caractère dans la langue utilisée lors de l'exécution.
Le développeur doit respecter certaine règles pour permettre une traduction efficace:
Ne pas utiliser de variable dans les messages :
begin // Message impossible à extraire (Erreur de compilation) : AMsg := _TP('L''objet '+inst.Caption+' ne remplit pas la condition ... '); // Forme correcte : AMsg := Format(_TP('L''objet %s ne remplit pas la condition ...'),[inst.Caption]); end;
Ne pas couper les messages en morceaux incompréhensibles :
begin // Message incompréhensible pour le traducteur : AMsg := _TP('L'objet') +inst.Caption+ _TP(' ne remplit pas la condition'); end;
Gérer l'ordre des paramètres dans les formats :
begin // L'ordre des paramètres pourra être inversé dans le message traduit. AMsg := Format(_TP('L''objet %1s ne remplit pas la condition exprimée par %2s'),[inst.Caption,AExpression]); end;
Voir aussi :
AS
AS est un opérateur de transtypage utilisable sur les classes métiers.
L'opérateur AS est évaluée à la compilation pour permettre au compilateur de connaître la classe de l'objet transtypé ET à l'exécution pour vérifier que la classe de l'objet est bien conforme à celle indiquée dans le transtypage.
Exemple :
function foo(inst:TitObject):Integer; begin // Si inst n'est pas un objet de MyClasse une exception sera levée. Result := (inst as MyClasse).MyVariable; end; function foo(inst:TitObject):Integer; var V:MyClasse; begin // Si inst n'est pas un objet de MyClasse une exception sera levée. V := (inst as MyClasse); Result := V.MyVariable; end;
IS
IS est un opérateur boolean qui teste si un objet est d'une classe métier particulière.
Exemple:
function foo(inst:TitObject):Integer; begin if (inst is MyClass) then begin ... end else if (inst is OtherClass) then begin .... end; end;