DOCUMENTATION EN LIGNE
DE WINDEV, WEBDEV ET WINDEV MOBILE
Aide / Tuto WEBDEV / Tuto - Les bases du WLangage
  • Leçon 6 - Les procédures
  • Présentation
  • Ma première procédure
  • Paramètres d'une procédure
  • Qu'est-ce qu'un paramètre ?
  • Gestion des paramètres : passage par référence ou par valeur
  • Renvoyer une valeur
  • Paramètres obligatoires ou optionnels ?
  • En résumé

Tuto - Les bases du WLangage

Leçon 6 - Les procédures
Ce que vous allez apprendre :
  • Création et appel d'une procédure.
  • Paramètres d'une procédure.
  • Résultat d'une procédure.
Durée de la leçon 20 mn
Présentation
Une procédure permet d'associer un identificateur (un nom) à une portion de code afin de la réutiliser.
Dans cette leçon, nous allons voir les différents types de procédures existant en WLangage, leur mode de création, comment les appeler, leur passer des paramètres et récupérer un résultat.
Ouvrez si nécessaire le projet "WLangage" que vous avez créé dans la première leçon de ce tuto (consultez le paragraphe Un projet pour découvrir le WLangage de la leçon 1).
Pour afficher les événements WLangage liés au projet :
  1. Dans la barre des éléments ouverts, faites un clic droit sur le bouton "P". Le menu contextuel s'affiche.
  2. Sélectionnez l'option "Code de l'élément".
  3. L'éditeur de code affiche les différents événements associés au projet.
  4. Si vous avez suivi les leçons précédentes, supprimez le code saisi dans l'événement "Initialisation" du projet (Ctrl + A pour tout sélectionner, et Suppr pour supprimer).
Ma première procédure
Une procédure est une suite d'instructions regroupée derrière un nom.
Par exemple, nous allons écrire une procédure qui affiche simplement un message.
Créer une procédure
Nous allons créer une procédure globale dans la collection de procédures du projet WLangage. Cette collection de procédures sera une collection de procédures serveur.
A retenir
Une collection de procédures permet de regrouper toutes les procédures globales à un projet. Ces procédures pourront être appelées depuis n'importe quel code du projet.
  1. Dans le volet "Code" du ruban, dans le groupe "Procédures", déroulez "Nouveau" et sélectionnez "Nouvelle procédure globale (Serveur)".
    Création d'une procédure globale
  2. Dans la fenêtre de sauvegarde de l'élément qui s'affiche, un nom est proposé par défaut pour la collection de procédures globales.
    Création d'une procédure globale
    Conservez ce nom et validez (bouton "OK").
  3. Une nouvelle fenêtre s'affiche permettant de saisir le nom de la procédure et ses caractéristiques :
    Création d'une procédure globale
    Arrêtons-nous un instant sur cette fenêtre. Il est possible :
    • d'indiquer le nom de la procédure. Un nom par défaut est proposé et peut être modifié.
    • de générer un commentaire d'en-tête. Ce commentaire contient les différentes caractéristiques de la procédure. Le contenu de ce commentaire est par défaut généré au fur et à mesure de la saisie du code de la procédure. Il peut également être modifié directement.
    • de définir la "portée" de la procédure. Une procédure globale est publique par défaut : elle est accessible depuis n'importe quel code. Dans certains cas, il est nécessaire de restreindre l'accès à une procédure globale. Elle peut être :
      • "Restreinte". Dans ce cas, la procédure globale est accessible soit par une autre procédure globale présente dans la collection de procédures soit par une procédure globale d'une autre collection de procédures du projet.
      • "Privée". Dans ce cas, la procédure globale est accessible uniquement par une autre procédure globale présente dans la collection de procédures.
    • d'indiquer le rôle de la procédure. Ce rôle est nécessaire lors du développement d'une application utilisant un découpage "Code métier / UI" (par exemple, avec une méthode de développement MV ou MVP). Pour plus de détails sur ce sujet, consultez Découpage code Métier / UI. Par défaut, ce rôle est "Non défini".
  4. Pour notre exemple, nous allons modifier uniquement le nom de la procédure et conserver les options par défaut. Indiquez le nom de la procédure "Bienvenue" et validez.
  5. La procédure globale "Bienvenue" est affichée sous l'éditeur de code.
    Création d'une procédure globale
    Cette procédure est composée :
    • de commentaires générés automatiquement.
    • du code : 
      PROCÉDURE Bienvenue()

      Ce code correspond au prototype de la procédure.
      A retenir
      Les éléments clé d'une procédure sont le mot-clé PROCEDURE suivi du nom de la procédure et de parenthèses.
  6. Nous pouvons saisir le contenu de notre procédure. Nous allons faire simple et afficher uniquement un message. Saisissez la ligne de code suivante : 
    Info("Bienvenue dans mon programme écrit en WLangage")
  7. Voilà, notre procédure est finie. mais pour voir le résultat de cette fonction, il faut l'appeler. C'est notre prochaine étape.
Appeler une procédure
Pour appeler une procédure, il suffit d'écrire son nom directement dans le code. Nous allons appeler notre procédure depuis le code d'initialisation du projet :
  1. Dans la barre des éléments ouverts, faites un clic droit sur le bouton "P". Le menu contextuel s'affiche.
  2. Sélectionnez l'option "Code de l'élément".
  3. L'éditeur de code affiche les différents événements associés au projet.
  4. Supprimez le code existant dans le code d'initialisation du projet et saisissez le code suivant : 
    Bienvenue()
  5. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  6. Le navigateur Web se lance et affiche une fenêtre d'information. Notre procédure s'est bien exécutée. Vous pouvez valider la fenêtre d'information.
Nous avons créé une procédure globale dans cet exemple. Le WLangage propose 3 types de procédures :
  • Procédure globale : ce type de procédure peut être appelé dans tous les événements et traitements du projet (procédure déclarée dans une collection de procédures). Pour plus de détails, consultez Procédure globale.
  • Procédure locale à une Fenêtre, Page ou Fenêtre mobile : ce type de procédure peut être appelé dans tous les événements et traitements dépendant de l'objet dans lequel cette procédure a été déclarée. Pour plus de détails, consultez Procédure locale.
    Il est également possible de créer des procédures locales à un champ. Ces procédures pourront être utilisées dans tous les événements WLangage associés au champ.
  • Procédure interne à un traitement ou à un événement : ce type de procédure peut être appelé uniquement dans le traitement ou l'événement dans lequel cette procédure a été déclarée. Pour plus de détails, consultez Procédure interne.
Paramètres d'une procédure

Qu'est-ce qu'un paramètre ?

Un paramètre est une valeur envoyée à une procédure lors de l'appel de la procédure.

Un exemple pratique
Pour comprendre le fonctionnement d'une procédure avec paramètre, nous allons manipuler une nouvelle procédure permettant de supprimer des espaces dans une chaîne de caractères.
Pour créer la nouvelle procédure :
  1. Dans le volet "Code" du ruban, dans le groupe "Procédures", déroulez "Nouveau" et sélectionnez "Nouvelle procédure globale (Serveur)".
  2. Si nécessaire, sélectionnez la collection de procédures "ProcéduresServeur" et validez.
  3. Dans la fenêtre qui s'affiche, indiquez le nom de la procédure à créer. Dans cet exemple, le nom de la procédure est "SupprimerEspace".
  4. Validez. La procédure globale "SupprimerEspace" est affichée sous l'éditeur de code.
  5. Saisissez le code suivant : 
    PROCÉDURE SupprimerEspace(ChaîneATraiter est une chaîne)
ChaîneATraiter = ChaîneATraiter.Remplace(" ", "")
Trace("La chaîne sans espace est : [%ChaîneATraiter%]")

    Dans ce code, la procédure manipule la chaîne de caractères qui lui est passée en paramètre. Les espaces sont supprimés (remplacés par une chaîne vide). Plusieurs points sont intéressants :
    • Cette procédure admet un paramètre ChaîneATraiter. Il est possible de passer aucune ou plusieurs valeurs en paramètre à une procédure. Ces valeurs peuvent être de tout type (comme pour les variables).
    • Le paramètre ChaîneATraiter est typé. Dans la déclaration de la procédure, il est indiqué que "ChaîneATraiter est une chaîne" : il ne sera pas possible d'utiliser cette procédure en passant une valeur numérique en paramètre par exemple.
  6. Dans le code d'initialisation du projet, supprimez le code existant et saisissez l'appel à la procédure : 
    MaChaîne est une chaîne
MaChaîne = "Bienvenue dans mon programme écrit en WLangage"
SupprimerEspace(MaChaîne)
  7. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  8. Affichez si nécessaire le volet "Trace du débogueur" pour voir le résultat : sous le volet "Accueil", dans le groupe "Environnement", déroulez "Volets" et sélectionnez "Volets" puis "Trace du débogueur".
  9. Dans la fenêtre de trace, nous obtenons le résultat suivant :
    La chaîne sans espace est : BienvenuedansmonprogrammeécritenWLangage

Gestion des paramètres : passage par référence ou par valeur

Par défaut, le WLangage utilise le passage de paramètre par référence (ou par adresse). Le paramètre dans la procédure représente (référence) directement la variable passée lors de l'appel.
Ainsi, lorsqu'une instruction de la procédure modifie la valeur du paramètre, la valeur de la variable correspondant à ce paramètre est modifiée dans le code appelant.
Reprenons notre exemple :
  • Dans notre exemple, la variable MaChaîne est donc modifiée. Pour le vérifier, il suffit d'ajouter après le code d'appel de la procédure la ligne de code suivante : 
    Trace("MaChaîne : " + MaChaîne)
  • Lors du test, le volet "Trace du débogueur" contient :
    La chaîne sans espace est BienvenuedansmonprogrammeécritenWLangage
    MaChaîne : BienvenuedansmonprogrammeécritenWLangage
Pour ne pas modifier la valeur de la variable correspondant au paramètre, il suffit d'utiliser le passage de paramètre par valeur. Le passage de paramètre par valeur permet de manipuler une copie de la valeur du paramètre. Si le code de la procédure modifie la valeur de la variable, la valeur de la variable correspondant au paramètre n'est pas modifiée.
Pour forcer le passage d'un paramètre par valeur à une procédure, il faut utiliser le mot-clé LOCAL devant le nom du paramètre dans la déclaration de la procédure. Ce mot-clé indique que le paramètre suivant ne sera pas modifié par la procédure.
Testons tout de suite cette fonctionnalité sur notre exemple :
  1. Positionnez le curseur de la souris sur le nom de la procédure "SupprimerEspace".
  2. Appuyez sur la touche F2. Le code WLangage de la procédure SupprimerEspace est affiché.
  3. Modifiez le code de déclaration de la procédure pour obtenir : 
    PROCÉDURE SupprimerEspace(LOCAL ChaîneATraiter est une chaîne)
  4. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  5. Lors du test, le volet "Trace du débogueur" contient :
    La chaîne sans espace est BienvenuedansmonprogrammeécritenWLangage
    MaChaîne : Bienvenue dans mon programme écrit en WLangage
    La variable MaChaîne n'est plus modifiée.
Dans une même procédure, certains paramètres peuvent être passés par référence et d'autres paramètres peuvent être passés par valeur. Il suffit d'utiliser le mot-clé LOCAL devant chaque paramètre passé par valeur.

Renvoyer une valeur

Une procédure peut renvoyer une valeur. Voici quelques exemples :
  • Une procédure peut renvoyer un booléen (Vrai/Faux) selon si le traitement a été effectué correctement ou non,
  • Une procédure peut renvoyer le résultat d'un calcul, etc.
Pour tester cette fonctionnalité, nous allons créer une nouvelle procédure qui va nous permettre de calculer le montant TTC d'un achat.
  1. Dans l'éditeur de code, utilisez la combinaison de touches Shift + F4.
  2. La fenêtre de création d'une procédure est affichée.
    • Saisissez le nom de la procédure : CalculTTC
    • Validez.
    • Saisissez le code de la procédure : 
      PROCÉDURE CalculTTC(LOCAL MontantHT est un monétaire, LOCAL TauxTVA est un réel) : monétaire
TTC est un monétaire
TTC = MontantHT * (1 + TauxTVA/100)
RENVOYER TTC

      Examinons le code de cette procédure :
      • Dans le code de déclaration de la procédure (appelé également "prototype de la procédure"), nous nous apercevons que cette procédure attend 2 paramètres (le montant hors taxe et la TVA).
      • Il y a 2 nouveautés dans ce code :
        • Le ": monétaire" situé à la fin permet d'indiquer que la valeur renvoyée est de type monétaire.
        • La procédure calcule le montant TTC et le renvoie grâce au mot-clé RENVOYER.
  3. Modifiez le code d'initialisation du projet pour appeler la procédure : 
    MontantTTC est un monétaire
MontantTTC = CalculTTC(500, 20)
Trace("Montant TTC : " + MontantTTC)
  4. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  5. Lors du test, le volet "Trace du débogueur" contient :
    Montant TTC : 600

Paramètres obligatoires ou optionnels ?

Les paramètres reçus dans la procédure peuvent être obligatoires ou optionnels. Un paramètre obligatoire doit être renseigné lors de l'appel de la procédure alors qu'un paramètre optionnel peut être omis : il prendra dans ce cas la valeur par défaut définie lors de la déclaration des paramètres de la procédure.
A retenir
Dans la déclaration d'une procédure, les paramètres optionnels sont toujours les derniers paramètres spécifiés (après tous les paramètres obligatoires).
Pour tester cette fonctionnalité, reprenons la procédure de calcul du montant TTC d'un achat.
Nous allons maintenant rendre le second paramètre optionnel. En effet, le montant de la TVA peut correspondre à 20 par défaut (les autres taux possibles étant 10, 5.5 ou 2.1).
  1. Positionnez le curseur de la souris sur le nom de la procédure "CalculTTC".
  2. Appuyez sur la touche F2. Le code WLangage de la procédure CalculTTC est affiché.
  3. Modifiez le code de déclaration de la procédure pour obtenir : 
    PROCÉDURE CalculTTC(LOCAL MontantHT est un monétaire, LOCAL TauxTVA est un réel=20) : monétaire
  4. Utilisez la combinaison de touches Ctrl + F2 pour retourner sur le code appelant (le code d'initialisation du projet).
  5. Modifiez l'appel à la procédure, en supprimant le second paramètre : 
    MontantTTC est un monétaire
MontantTTC = CalculTTC(500)
Trace("Montant TTC : " + MontantTTC)
  6. Testons immédiatement ce code : cliquez sur Tester le projet parmi les boutons d'accès rapide.
  7. Lors du test, le volet "Trace du débogueur" contient :
    Montant TTC : 600
    Le résultat n'a pas changé car la valeur par défaut a été utilisée.
En résumé
Dans cette leçon, vous avez découvert :
  • Comment créer et appeler une procédure WLangage,
  • Comment passer des paramètres à une procédure WLangage,
  • Comment renvoyer une valeur, etc.
Dans la prochaine leçon, nous verrons comment utiliser le débogueur pour suivre le code exécuté.
Leçon précédenteSommaireLeçon suivante
Version minimum requise
  • Version 2024
Commentaires
Cliquez sur [Ajouter] pour publier un commentaire

Dernière modification : 15/11/2023

Signaler une erreur ou faire une suggestion | Aide en ligne locale