Instructions et opérateurs

Instructions DelphiScript

Une instruction en DelphiScript est considérée comme « simple » lorsqu’elle ne contient aucune autre instruction. Les instructions d’affectation et les appels de procédure sont des exemples d’instructions simples.

Simple statements:

X := Y + 10; // assignment

ShowMessage('Hello World!'); // procedure call

Une instruction composée se compose de plusieurs instructions.

Compound statements:

Begin
  If A > B Then ShowMessage('A is bigger');
  Else ShowMessage('B is bigger');
  A := 0;
  B := 0;
End;

Instructions conditionnelles

DelphiScript dispose d’instructions de contrôle qui influencent le flux d’exécution au sein d’un script. L’instruction de contrôle la plus courante est l’instruction conditionnelle If..Then.

Instruction If Then

L’instruction If..Then est utilisée pour le contrôle conditionnel. La syntaxe est la suivante :

If Condition Then
  Begin
  // code here
  End
Else
  Begin
  // code here
  End;

Instruction Case Of

Pour éviter un ensemble complexe d’instructions If, celles-ci peuvent souvent être remplacées par des instructions Case. Une instruction case dans une expression est utilisée pour sélectionner une valeur, une liste de valeurs possibles ou une plage de valeurs.

N’importe quel type peut être utilisé dans une instruction Case, car DelphiScript est un langage non typé. Les instructions Case peuvent comporter une instruction Else, exécutée si aucune des étiquettes ne correspond à la valeur du sélecteur (dans la condition Case Of).

Example 1:

Case Char of
  '+' : Text := 'Plus sign';
  '-' : Text := 'Minus sign';
  '*', '/': Text := 'Multiplication or division';
  '0'..'9': Text := 'Number';
  'a'..'z': Text := 'Lowercase character';
  'A'..'Z': Text := 'Uppercase character';
else
  Text := 'Unknown character';
End;

Example 2:

Case UserName of
  'Jack', 'Joe' : IsAdministrator := true;
  'Fred' : IsAdministrator := false;
else
  Raise('Unknown User');
End;

Instruction With

L’instruction With est une forme abrégée en DelphiScript. Lorsqu’on fait référence à une variable de type enregistrement (ou à un objet), une instruction « with » peut être utilisée au lieu de répéter son nom à chaque fois.

Normal version:

Form.Canvas.Pen.Width := 2;
Form.Canvas.Pen.Color := clSilver;

Version using With:

With Form.Canvas.Pen do
Begin
  Width := 2;
  Color := clSilver;
End;

Boucle For To Do

L’instruction For..To..Do fournit une méthode permettant de parcourir de manière répétée un bloc de code (une ou plusieurs lignes de code). La syntaxe de base est la suivante :

For counter := start To end Do
Begin
  // code here
End;

ForLes boucles sont souvent utilisées pour initialiser un tableau. Le sens du compteur dans une boucle For..To..Do peut être contrôlé en utilisant alternativement le mot-clé DownTo pour décrémenter la boucle. DelphiScript fournit l’instruction Break/Exit pour quitter prématurément une boucle For..To..Do.

Boucle Repeat Until

L’instruction Repeat est exécutée de manière répétée jusqu’à ce que l’expression booléenne soit vraie. L’instruction Repeat est toujours exécutée au moins une fois.

Example:

Repeat
  Write('Enter a value (0..9): ');
  ShowMessage(IntToStr(I));
Until (I >= 0) and (I <= 9);

Boucle While Do

Une instruction While est similaire à une instruction Repeat, sauf que la condition de contrôle est évaluée avant la première exécution de la séquence d’instructions. Ainsi, si la condition est fausse, la séquence d’instructions n’est jamais exécutée.

Example:

Randomize;
I := 0;
While I < 1000 do
Begin
  I := I + Random (100);
  Add ('Random Number: ' + IntToStr (I));
End;

Instruction Continue

L’instruction Continue saute le corps d’une boucle, de manière similaire à l’instruction Goto. L’instruction continue fait passer le script en cours d’exécution à l’itération suivante dans la boucle For, While ou Repeat en cours.

Example:

var
  F: File;
  i: Integer;
Begin
  For i := 0 to (FileListBox1.Items.Count - 1) do
  Begin
    Try
    If FileListBox1.Selected[i] Then
    Begin
      If not FileExists(FileListBox1.Items.Strings[i]) then
      Begin
        MessageDlg('File: ' + FileListBox1.Items.Strings[i] + 'not found', mtError, [mbOk], 0);
        Continue;
      End;
      AssignFile(F, FileListBox1.Items.Strings[i]);
      Reset(F, 1);
      ListBox1.Items.Add(IntToStr(FileSize(F)));
      CloseFile(F);
    End;
    Finally
      { do something here }
    End;
  End;
End;

Instruction Goto Label

L’instruction Goto a la forme Goto label, qui transfère l’exécution du script vers l’instruction marquée par l’étiquette spécifiée. Pour marquer une instruction, l’étiquette doit d’abord être déclarée, puis l’instruction cible doit être précédée de l’étiquette et de deux-points : label: statement

Une étiquette peut être n’importe quel identifiant valide. La déclaration de l’étiquette et l’instruction Goto doivent appartenir au même bloc de code dans un script. Il n’est donc pas possible de sauter à l’intérieur ou à l’extérieur d’une procédure ou d’une fonction.

Example:

Label StartHere;
  // code
StartHere: Beep;
Goto StartHere;

Instruction Exit

L’instruction Exit retourne immédiatement depuis une fonction ou une procédure. Si vous appelez Exit depuis un bloc Try..Finally, la partie Finally est exécutée avant le retour de la sous-routine. Si la procédure Exit est appelée depuis le corps principal du script, l’exécution du script se termine.

Example:

Begin
  Server := SchServer;
  If Server = Nil Then
  Begin
    ShowError('No SchServer started');
    Exit;
End;

Instruction Break

L’instruction Break fait quitter au script en cours d’exécution la boucle For, While ou Repeat actuelle. L’exécution du script se poursuit à la ligne exécutable suivante après la boucle en cours.

Example:

Var
  S: string;
Begin
  While True do
  Begin
    ReadLn(S);
    Try
      if S = '' then Break;
      WriteLn(S);
    Finally
      { do something for all cases }
    End;
  End;
End;

Opérateurs d’expression DelphiScript

De manière générale, une expression est une combinaison valide de constantes, variables, valeurs littérales, opérateurs et résultats de fonctions. Les expressions sont utilisées pour déterminer la valeur à affecter à une variable, pour calculer le paramètre d’une fonction ou pour tester une condition. Les expressions peuvent inclure des appels de fonction.

DelphiScript possède un certain nombre d’opérateurs logiques, arithmétiques, booléens et relationnels. Ces opérateurs sont regroupés selon leur ordre de priorité (voir ci-dessous), qui diffère des ordres de priorité utilisés par Basic, C, etc. Par exemple, les opérateurs AND et OR ont une priorité par rapport aux opérateurs relationnels.

Si vous écrivez a<b and c<d, DelphiScript effectuera d’abord l’opération AND, ce qui entraînera une erreur. Pour éviter ce problème et définir la priorité, chaque expression < doit être placée entre parenthèses : (a<b) and (c<d);

Les opérateurs DelphiScript pris en charge ci-dessous sont présentés dans leur ordre de priorité.

Opérateurs regroupés par priorité

Notez que les opérateurs unaires ont la priorité la plus élevée.

Multiplicative and Bitwise Operators

Additive Operators

Relational and Comparison Operators (lowest precedence)

Notez également que les opérateurs ^ et @ ne sont pas pris en charge par DelphiScript.