Comment utiliser les fonctions et procédures dans Delphi

Vous êtes-vous déjà retrouvé à écrire le même code encore et encore pour effectuer une tâche courante dans gestionnaires d'événements? Oui! Il est temps pour vous d'en apprendre davantage sur les programmes d'un programme. Appelons ces sous-programmes de mini-programmes.

Les sous-programmes sont une partie importante de tout langage de programmation, etDelphes ne fait pas exception. Dans Delphi, il existe généralement deux types de sous-programmes: une fonction et une procédure. La différence habituelle entre une fonction et une procédure est qu'une fonction peut renvoyer une valeur et qu'une procédure ne le fera généralement pas. Une fonction est normalement appelée en tant que partie d'une expression.

Jetez un œil aux exemples suivants:

procédure Dis bonjour(const sQuoi:chaîne); commencer
ShowMessage ('Bonjour' + sWhat); fin; une fonction Ans(const BirthYear: entier): entier; var
Année, mois, jour: Word; commencer
DecodeDate (date, année, mois, jour); Résultat: = Year - BirthYear; fin; 

Une fois les sous-programmes définis, nous pouvons les appeler une ou plusieurs fois:

procédure TForm1.Button1Click (expéditeur: TObject); commencer
SayHello («Utilisateur Delphi»); fin; procédure TForm1.Button2Click (expéditeur: TObject); commencer
SayHello («Zarko Gajic»); ShowMessage ('Vous êtes' + IntToStr (YearsOld (1973)) + 'ans!'); fin; 

Comme nous pouvons le voir, les fonctions et les procédures agissent comme des mini-programmes. En particulier, ils peuvent avoir leur propre type, constantes et déclarations de variables à l'intérieur.

Examinez de plus près une fonction (divers) de SomeCalc:

une fonction SomeCalc. (const sStr: chaîne; const iYear, iMonth: entier; var iDay: entier): booléen; commencer...fin; 

Chaque procédure ou fonction commence par un entête qui identifie la procédure ou la fonction et répertorie les paramètres la routine utilise le cas échéant. Les paramètres sont répertoriés entre parenthèses. Chaque paramètre a un nom identifiant et a généralement un type. Un point-virgule sépare les paramètres d'une liste de paramètres les uns des autres.

sStr, iYear et iMonth sont appelés paramètres constants. Les paramètres constants ne peuvent pas être modifiés par la fonction (ou la procédure). L'iDay est passé en tant que paramètre var, et nous pouvons y apporter des modifications, à l'intérieur du sous-programme.

Les fonctions, puisqu'elles renvoient des valeurs, doivent avoir un type de retour déclaré à la fin de l'en-tête. La valeur de retour d'une fonction est donnée par l'affectation (finale) à son nom. Étant donné que chaque fonction possède implicitement une variable locale Résultat du même type que la valeur de retour des fonctions, l'affectation à Résultat a le même effet que l'attribution au nom de la fonction.

Les sous-programmes sont toujours placés dans la section de mise en œuvre de l'unité. Ces sous-programmes peuvent être appelés (utilisés) par un gestionnaire d'événements ou un sous-programme dans la même unité que celle définie après.

Remarque: la clause uses d'une unité vous indique quelles unités elle peut appeler. Si nous voulons qu'un sous-programme spécifique dans une unité1 soit utilisable par les gestionnaires d'événements ou des sous-programmes dans une autre unité (disons unité2), nous devons:

• Ajoutez Unit1 à la clause uses de Unit2
• Placez une copie de l'en-tête du sous-programme dans la section interface de Unit1.

Cela signifie que les sous-programmes dont les en-têtes sont donnés dans la section interface sont de portée mondiale.

Lorsque nous appelons une fonction (ou une procédure) à l'intérieur de sa propre unité, nous utilisons son nom avec tout paramètres sont nécessaires. D'autre part, si nous appelons un sous-programme global (défini dans une autre unité, par exemple MyUnit), nous utilisons le nom de l'unité suivi d'un point.

... // La procédure SayHello est définie à l'intérieur de cette unité
SayHello («Utilisateur Delphi»); // La fonction YearsOld est définie dans l'unité MyUnit
Factice: = MyUnit. Ans (1973);... 

Remarque: les fonctions ou procédures peuvent avoir leurs propres sous-programmes intégrés. Un sous-programme incorporé est local au sous-programme de conteneur et ne peut pas être utilisé par d'autres parties du programme. Quelque chose comme:

procédure TForm1.Button1Click (expéditeur: TObject); une fonction Est petite(const sStr:chaîne): booléen; commencer// IsSmall renvoie True si sStr est en minuscules, False sinon
Résultat: = LowerCase (sStr) = sStr; fin; commencer// IsSmall ne peut être utilisé qu'à l'intérieur de l'événement Button1 OnClicksi IsSmall (Edit1.Text) ensuite
ShowMessage ('Toutes les petites majuscules dans Edit1.Text')
autre
ShowMessage ('Pas toutes les petites majuscules dans Edit1.Text'); fin;