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 est constituée 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 déroulement de l'exécution au sein d'un script. L'instruction de contrôle la plus courante est l' If..Then instruction conditionnelle.

Instruction If Then

L' If..Then instruction est utilisée pour le contrôle conditionnel. Sa 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’ If instructions, celles-ci peuvent souvent être remplacées par Case instructions. Une instruction « Case » dans une expression sert à sélectionner une valeur, une liste de valeurs possibles ou une plage de valeurs.

Tous les types peuvent être utilisés dans une instruction Case, car DelphiScript est un langage non typé. Les instructions Case peuvent comporter une instruction Else qui est exécutée si aucune des étiquettes ne correspond à la valeur du sélecteur (au sein de 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' With instruction « with » est une syntaxe abrégée de 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' For..To..Do instruction permet d’exécuter en boucle 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;

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

Boucle « Repeat Until »

L’ Repeat instruction est exécutée de manière répétée jusqu’à ce que l’expression booléenne soit vraie. L’ Repeat instruction 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 While instruction est similaire à une Repeat instruction « While », à la différence que la condition de contrôle est évaluée avant la première exécution de la séquence d’instructions. Par conséquent, 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' Continue instruction « continue » permet de sauter le corps d’une boucle, à l’instar de l’ Goto . L'instruction continue fait passer le script en cours d'exécution à l'itération suivante de la boucle For, While ou Repeat boucle.

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' Goto instruction se présente sous 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 d'un deux-points : label: statement

Un étiquette peut être n'importe quel identifiant valide. La déclaration de l'étiquette et l' Goto l'instruction doivent appartenir au même bloc de code au sein d'un script. Il n'est donc pas possible d'effectuer un saut vers une procédure ou une fonction, ni d'en sortir.

Example:

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

Instruction Exit

L' Exit instruction provoque le retour immédiat d’une fonction ou d’une procédure. Si vous l’appelez Exit depuis l’intérieur d’un Try..Finally bloc, la Finally partie est exécutée avant que la sous-routine ne revienne. Si la Exit procédure est appelée depuis le corps principal du script, l’exécution de ce dernier s’arrête.

Example:

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

Instruction Break

L' Break instruction provoque la sortie du script en cours d’exécution de la For, While ou Repeat boucle. L'exécution du script se poursuit à partir de 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

En général, une expression est une combinaison valide de constantes, de variables, de valeurs littérales, d’opérateurs et de résultats de fonctions. Les expressions servent à déterminer la valeur à attribuer à une variable, à calculer le paramètre d’une fonction ou à vérifier une condition. Les expressions peuvent inclure des appels de fonction.

DelphiScript dispose d’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, l’opérateur AND et OR ont une priorité supérieure à celle de l’opérateur relationnel.

Si vous écrivez a, DelphiScript effectuera d’abord l’ AND opération en premier, 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;

Les opérateurs DelphiScript pris en charge, répertoriés ci-dessous, sont classés par ordre de priorité.

Opérateurs classés par ordre de 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 le ^ et @ ne sont pas pris en charge par DelphiScript.