====== Function, Procedure et Property ======
===== Déclaration des procedures et functions =====
==== Deprectated ====
Pour signifier au développeur qu'il utilise un fonction qui est obsolète, on peut aussi ajouter un message, comme ceci :
<code pascal>
procedure FreeThenNil(var obj); deprecated 'Use LazUtilities.FreeThenNil instead';
</code>
==== Of Object ====
La syntaxe correcte pour déclarer une fonction ou une méthode qui peut être assignée à un pointeur de méthode (souvent utilisé pour les événements) en Pascal (Delphi/Lazarus) est la suivante :
<code pascal>
// Pour un procedure
  TStateChangeEvent = procedure(Sender: TObject; AState: TState; AObject: TObject) of object;

//Pour une Function
  TMyFuncEvent = function(Sender: TObject): boolean of object;

</code>



===== Parametres =====
==== Types de paramètres ====
Source : [[https://www.freepascal.org/docs-html/ref/refse91.html]]
=== Value parameters ===
<note>ToDo</note>
=== Variable parameters ===
<note>ToDo</note>
=== Out parameters ===
Le but d'un paramètre ''out'' est de renvoyer des valeurs à la routine appelante : la variable est passée par référence.\\
La valeur initiale du paramètre à l'entrée de la fonction est rejetée, et ne doit pas être utilisée.

Si une variable doit être utilisée pour passer une valeur à une fonction et récupérer des données de la fonction, alors un paramètre''var'' doit être utilisé. 

Si seule une valeur doit être récupérée, un paramètre ''out'' peut être utilisé.

Il va sans dire que les valeurs par défaut ne sont pas prises en charge pour les paramètres ''out''.

La différence entre les paramètres ''out''  et les paramètres de référence est très faible (cependant, voir ci-dessous pour les types gérés) : le premier donne au compilateur plus d'informations sur ce qu'il advient des arguments lorsqu'ils sont passés à la procédure : il sait que la variable n'a pas besoin d'être initialisée avant l'appel. 

L'exemple suivant en est une illustration :

<code delphi>
Procedure DoA(Var A : Integer);  
 begin  
  A:=2;  
  Writeln(’A is ’,A);  
end;  

Procedure DoB(Out B : Integer);  
begin  
  B:=2;  
  Writeln(’B is ’,B);  
end;  
 
Var  
  C,D : Integer;  
 
begin  
  DoA(C);  
  DoB(D);  
end.
</code>
Les deux procédures DoA et DoB font pratiquement la même chose. Mais la déclaration de la DoB donne plus d'informations au compilateur, lui permettant de détecter que D n'a pas besoin d'être initialisé avant l'appel de la DoB. Comme le paramètre A de la DoA peut recevoir une valeur aussi bien que d'en renvoyer une, le compilateur constate que C n'a pas été initialisé avant l'appel à la DoA :

home : >fpc -S2 -vwhn testo.pp  
testo.pp(19,8) Indice : la variable "C" ne semble pas être initialisée
Cela montre qu'il est préférable d'utiliser des paramètres lorsque le paramètre est utilisé uniquement pour renvoyer une valeur.
Remarque : Les paramètres out ne sont supportés qu'en mode Delphi et ObjFPC. Pour les autres modes, out est un identifiant valide.
Remarque : Pour les types gérés (types comptés de référence), l'utilisation des paramètres Out entraîne un certain surcroît de travail : le compilateur doit s'assurer que la valeur est correctement initialisée (c'est-à-dire qu'elle a un compte de référence de zéro (0)). Cette initialisation est normalement effectuée par l'appelant.

Source:[[https://www.freepascal.org/docs-html/ref/refsu66.html]]
=== Constant parameters ===
<note>ToDo</note>
=== Open array parameters ===
<note>ToDo</note>
=== Array of const ===
<note>ToDo</note>
==== Valeur par défaut d'un paramètre ====
L'exemple suivant affiche 20 à l’écran.
<code delphi>
program testp;  
Const  
  MyConst = 20;  

Procedure MyRealFunc(I : Integer = MyConst);  
begin  
  Writeln(’Function received : ’,I);  
end;  
 
begin  
  MyRealFunc;  
end.
</code>
Source:[[https://www.freepascal.org/docs-html/ref/refsu64.html]]

===== Properties =====
<code delphi>
property ReadOnly: Boolean read GetReadOnly write SetReadOnly default false;
</code>