Créée le, 19/06/2015

 Mise à jour le, 12/05/2019

Visiteurs N°  




Accueil
Nouveau Blog Nouveautés Moteur de Recherche Votre Caddie Pour Vos Achats Votre Espace Membre Vos Signets et Vos Jeux Préférés Page de Bienvenue Statique Site en Français Site en Anglais
Sommaires
Électronique Fondamentale Technologie Fondamentale Testez vos Connaissances Électronique Théorique Digitale Électronique Pratique Digitale Lexique Électronique Numérique Data book TTL Data book CMOS Dépannage TVC Mathématique
Micro-ordinateurs
Théorique des Micro-ordinateurs Testez vos Connaissances Pratique des Micro-ordinateurs Glossaires sur les Ordinateurs
Physique
La lumière Champ d'action Rayonnement Électromagnétique
Technologies
Classification des Résistances Identification des Résistances Classification des Condensateurs Identification des Condensateurs
Formulaires Mathématiques
Géométrie Physique 1. - Électronique 1. 2. - Électronique 1. 3. - Électrotechnique 1. 4. - Électromagnétisme
Accès à tous nos Produits
E. T. F. - Tome I - 257 Pages E. T. F. - Tome II - 451 Pages E. T. F. - Tome III - 611 Pages E. T. D. - Tome I - 610 Pages N. B. M. - Tome I - 201 Pages E. T. M. - Tome I - 554 Pages Business à Domicile Ouvrages 34 pages gratuits Nos E-books Logiciel Géométrie Logiciel Composants Électroniques
Aperçu de tous nos Produits
E. T. F. - Tome I - 257 Pages E. T. F. - Tome II - 451 Pages E. T. F. - Tome III - 611 Pages E. T. D. - Tome I - 610 Pages E. T. M. - Tome I - 554 Pages Logiciel Géométrie Logiciel Composants Électroniques
Nos Leçons aux Formats PDF
Électronique Fondamentale Technologie Fondamentale Électronique Théorique Digitale Électronique Pratique Digitale Théorique des Micro-ordinateurs Mathématiques
Informatique
Dépannage Win98 et WinXP et autres Dépannage PC Glossaire HTML et Programmes PHP et Programmes JavaScript (en cours de travaux) Création de plusieurs Sites
Forums
Forum Électronique et Infos Forum Électronique et Poésie
Divers et autres
Formulaire des pages perso News XML Statistiques CountUs Éditeur JavaScript Nos Partenaires et nos Liens Utiles Gestionnaire de Partenariat Nos Partenaires MyCircle Sondages 1er Livre d'Or 2ème livre d'Or

Signets :
  Leçons suivantes        Leçons précédentes     Bas de page
  Cliquez ici pour la leçon suivante ou dans le sommaire prévu à cet effet


Utilisation de fonctions, en PHP (2ème partie) :



Les fonctions existent dans la plupart des langages de programmation. Elles s'emploient pour séparer du code qui accomplit une tâche unique et bien définie. Les fonctions rendent le code plus lisible, et permettent de réutiliser le code chaque fois qu'une même tâche doit être accomplie.

Une fonction est un module de code autonome auquel est associée une interface d'appel, qui accomplit une certaine tâche, et qui renvoie éventuellement un résultat.

Nous avons déjà étudié diverses fonctions. Dans les chapitres précédents, nous avons régulièrement invoqué des fonctions prédéfinies dans PHP. Par ailleurs, nous avons nous-même écrit quelques fonctions simples, sans toutefois entrer dans les détails. Dans cette section du second chapitre, nous allons nous pencher plus attentivement sur l'invocation et l'écriture de fonctions.

Invocation (appel) de fonctions :

Le plus simple appel de fonction envisageable est le suivant :

    ma_fonction ;

Cette ligne de code invoque la fonction dénommée ma_fonction, qui ne prend pas de paramètre. Elle ignore toute valeur éventuellement renvoyée par la fonction.

Nombre de fonctions s'invoquent exactement de cette manière. Par exemple, c'est le cas de la fonction phpinfo(), qui est très utile lors de tests parce qu'elle affiche la version installée de PHP, des informations relatives à PHP, la configuration du serveur Web et les valeurs de diverses variables PHP et serveur. Cette fonction ne prend aucun paramètre, et la valeur qu'elle renvoie et le plus souvent ignorée. L'invocation de la fonction phpinfo() est donc souvent implémentée de la manière suivante :

    phpinfo() ;

Une portion d'un aperçu de phpinfo() ci-après : (et nous ne pouvons mettre toutes les informations de cette fonction pour manque de place).

Apercu_de_php_info.png

La plupart des fonctions requièrent un ou plusieurs paramètres, qui fournissent à la fonction les informations nécessaires à l'accomplissement de la tâche, et qui vont influencer le résultat de l'exécution de la fonction. Les paramètres, également appelés arguments, sont passés à une fonction sous la forme de données, ou de noms de variables contenant les données, placées entre parenthèses à la suite du nom de la fonction. L'invocation d'une fonction prenant un seul paramètre s'implémente comme suit :

    ma_fonction("parametre") ;

Dans ce cas, le paramètre spécifié est une chaîne contenant seulement le mot paramètre. Les appels de fonction qui suivent sont également valident, selon la fonction invoquée :

    ma_fonction(4) ;

    ma_fonction(7.984) ;

    ma_fonction($variable) ;

Dans la dernière de ces trois lignes de code, $variable peut être une variable PHP de tout type, y compris un tableau. ([]).

Les paramètres peuvent être de tous types, mais en général, chaque fonction requiert un, ou des paramètres, avec des types de données spécifiques.

Le "prototype" d'une fonction décrit le nombre de paramètres requis, ainsi que la signification et le type de données de chaque paramètre. Cette leçon donne généralement le prototype de chaque fonction décrite. Vous trouverez, en outre, le jeu exhaustif des prototypes des fonctions PHP que nous avions examiné et fort bien utile dédié à PHP, et situé à l'URL ci-après : prototypes des fonctions PHP.

Le prototype de la fonction fopen() est le suivant :

    int fopen (string nom_du_fichier, string mode, [int utiliser_include_path] );

Le prototype d'une fonction fournit de précieuses indications sur la fonction, qu'il est important de savoir interpréter. Dans le prototype de la fonction fopen(), le terme int placé avant le nom de la fonction indique que la fonction renvoie un nombre entier. Les paramètres (ou arguments) de la fonction sont spécifiés entre parenthèses, fopen() prend trois paramètres, décrits par le prototype de la fonction. Les paramètres mode et nom_du_fichier sont des chaînes, tandis que le paramètre utiliser_include_path est un nombre entier. La présence de crochets de part et d'autre du paramètre utiliser_include_path indique que ce dernier est optionnel. Vous pouvez fournir une valeur à un paramètre optionnel, ou bien choisir de l'ignorer, auquel cas, l'interpréteur PHP utilisera sa valeur par défaut.

Après lecture du prototype de la fonction fopen(), nous pouvons affirmer que, dans le fragment de code qui suit, l'appel de la fonction fopen() est valide :

    $Nom = "Mon_fichier.txt" ;

    $File_mode = "r" ;

    $fp = fopen($Nom, $File_mode) ;

Ce code invoque la fonction dénommée fopen(). La valeur renvoyée par cette dernière est ensuite stockée dans la variable $fp. Une variable dénommée $Nom est passée à la fonction fopen() comme premier argument. Cette variable contient une chaîne représentant le nom du fichier à ouvrir. Le deuxième argument passé à la fonction fopen() est une variable appelée $File_mode, et qui contient une chaîne représentant le mode d'ouverture du fichier. Dans cet exemple d'invocation de la fonction fopen(), le troisième paramètre n'est pas fourni.

Appel d'une fonction non définie :

L'appel d'une fonction qui n'existe pas provoque la génération d'un message d'erreur, tel que celui montré à la figure 1.

Erreur_Fatale_sur_ligne_4.png

Les messages d'erreur affichés par l'interpréteur PHP sont généralement très utiles. Celui de la figure 1, nous indique exactement le contexte dans lequel s'est produite l'erreur, c'est-à-dire le nom du fichier, le numéro de la ligne du script, et le nom de la fonction qui a été invoquée et qui n'existe pas. Ces indications permettent, en principe, de corriger facilement et rapidement l'erreur survenue.

A l'affichage d'un tel message d'erreur, vous devez examiner deux questions :

Petite_Main.gif  Le nom de la fonction est-il correctement orthographié dans le script ?

Petite_Main.gif  La fonction invoquée existe-t'elle dans la version de PHP utilisée ?

Les noms des fonctions sont parfois difficiles à mémoriser. Par exemple, certaines fonctions prédéfinies dans PHP ont des noms composés de deux mots séparés par un caractère de soulignement comme strip_tags(), tandis que d'autres, ont des noms formés de deux mots accolés comme stripslashes(). La présence d'une faute d'orthographe dans le nom d'une fonction provoque l'erreur montrée à la figure 1.

Nombre de fonctions décrites dans cette leçon n'existent pas dans la version 3.0 de PHP : nous partons, en effet, ici du principe que vous êtes au moins équipé de la nouvelle version supérieure à 5.3.8. Chaque nouvelle version de PHP apporte son lot de nouvelles fonctions, qui enrichissent la fonctionnalité et la performance du langage, et justifient de ce fait une mise à jour pour tous ceux utilisant la version précédente. Vous pourrez trouver dans le manuel en ligne de PHP en cliquant ici, la date d'ajout de chaque fonction disponible. L'invocation d'une fonction non déclarée dans la version PHP utilisée provoque l'erreur dont le message est montré à la figure 1. Et pour finir, nous allons expliquer, pourquoi créer ses propres fonctions ? Et on verra dans ce chapitre, les structures de base d'une fonction par exemple.

La Casse et Noms de Fonctions :

Notez que les appels de fonctions ne sont pas sensibles à la casse (emploi de majuscules et minuscules). Ainsi, les appels de fonction_nom(), Fonction_Nom(), et FONCTION_NOM() sont tous valides, et conduisent au même résultat. Vous êtes libre de choisir la casse qui vous convient, et que vous jugez plus facile à lire. Veillez toutefois à rester cohérent. Dans cette leçon, comme dans la plupart des ouvrages de programmation, la convention adoptée consiste à placer tous les noms de fonctions en minuscules.

Les noms de fonction se comportent différemment des noms de variables. Les noms de variables sont, eux, sensibles à la casse, de telle sorte que $Name et $name désignent deux variables différentes, tandis que Name() et name() désignent la même fonction.

Au cours des leçons précédentes, nous avons été amenés à étudier et à utiliser nombre de fonctions prédéfinies dans le langage PHP. Toutefois, la réelle puissance d'un langage de programmation tient dans la possibilité de créer ses propres fonctions d'utilisateur.

Pourquoi définir ses propres fonctions ? :

Grâce aux fonctions prédéfinies dans PHP, vous pouvez interagir avec des fichiers, manipuler une base de données (que l'on verra par la suite au cours des prochains chapitres), créer des images, et établir la connexion avec d'autres serveurs. Malgré la richesse des possibilités qui sont ainsi offertes, le programmeur se trouve fréquemment en situation, d'implémenter une tâche pour laquelle aucune fonction n'a été prédéfinie dans PHP.

Il est heureusement possible de créer des "fonctions utilisateur" (personnalisées), en sus des fonctions prédéfinies dans PHP, pour accomplir toute tâche de votre goût. Le code du programmeur est souvent une combinaison de fonctions existantes et de logique personnalisée accomplissant des tâches particulières. Lorsque vous êtes amené à écrire un bloc de code pour implémenter une tâche, que vous prévoyez d'accomplir en d'autres points de votre script, voire dans d'autres scripts, vous avez tout intérêt à déclarer ce bloc de code en tant que fonction.

Déclarer une fonction permet d'utiliser du code personnalisé à la manière des fonctions prédéfinies dans PHP : il suffit d'invoquer la fonction utilisateur, en lui fournissant les paramètres requis. Vous pouvez ainsi appeler et réutiliser la même fonction plusieurs fois dans un même script.

Structure de base d'une fonction :

Une déclaration de fonction crée, ou "déclare", une nouvelle fonction. Une déclaration commence par le mot clé function, spécifie le nom de la fonction, les paramètres requis, et contient le code à exécuter à chaque invocation de la fonction.

La déclaration d'une fonction triviale s'effectue de la manière suivante :

     function ma_fonction()

    {

       echo "Ma fonction a été invoquée." ;

    }

Cette déclaration de fonction commence par function, de sorte qu'humains et l'interpréteur PHP soient informés que le code qui suit est celui d'une fonction utilisateur. Le nom de la fonction étant ma_fonction, nous pouvons invoquer notre nouvelle fonction au moyen de l'instruction suivante :

    ma_fonction() ;

Comme vous l'avez probablement deviné, l'appel de cette fonction se traduit par l'affichage dans la fenêtre du navigateur du texte : "Ma fonction a été invoquée.".

Alors que les fonctions prédéfinies dans PHP sont utilisables dans tous les scripts PHP, les fonctions utilisateur ne sont utilisables qu'à partir des scripts dans lesquels elles ont été déclarées. Il est recommandé de rassembler dans un même fichier toutes les fonctions utilisateur couramment utilisées. Cette astuce permet en effet, au programmeur d'accéder à toutes ses fonctions personnalisées par une simple instruction require() ou include() insérée dans chacun des scripts.

Au sein d'une déclaration de fonction, le code accomplissant la tâche requise doit être placé entre accolades. Ce code peut contenir tout ce qui est légal dans un script PHP, y compris des appels d'autres fonctions, des déclarations de nouvelles variables ou fonctions, des instructions require() ou include(), et du plein HTML. Lorsque, au sein d'une fonction, il est nécessaire de quitter PHP et de taper du plein HTML, il suffit de procéder comme en tout autre point d'un script, en plaçant une balise PHP de fermeture avant le code HTML.

Le code qui suit est une variante légale de l'exemple précédent, et qui conduit au même résultat :

    <?PHP

        function ma_fonction()

          {

    ?>

       <BR /> <font face = 'Arial'> Ma fonction a &eacute;t&eacute; invoqu&eacute;e. </font>

    <?PHP

          }

       ma_fonction() ;

    ?>

Veuillez noter que le code PHP est contenu entre des paires de balises PHP d'ouverture et de fermeture. Dans la plupart des fragments de code donnés en exemple dans cette leçon, ces balises ne sont pas montrées. Nous les avons données dans cet exemple, parce qu'elles y sont indispensables.

Attribution d'un nom à une fonction :

Votre souci principal, lors du choix d'un nom pour une fonction utilisateur, devrait être d'adopter un nom explicite. Par exemple, pour une fonction créant un en-tête de page Web, les noms pageheader() ou page_header() seraient appropriés.

Les quelques restrictions à prendre en compte lors du choix des noms de fonctions sont les suivantes :

Petite_Main.gif  Ne donnez pas à une fonction un nom déjà attribué à une autre fonction.

Petite_Main.gif  Un nom de fonction ne peut contenir que des lettres, des chiffres et des caractères de soulignement.

Petite_Main.gif  Un nom de fonction ne doit pas commencer par un chiffre.

Petite_Main.gif  Evitez les ponctuations ou les accents aigu ainsi que les accents grave dans les fonctions et programmes en PHP, sinon pose problème dans certain cas.

Nombre de langages de programmation autorisent la réutilisation des noms de fonctions. On parle alors de "surcharge de fonction" (overloading). PHP interdit toutefois la surcharge de fonction, c'est-à-dire qu'il ne permet pas de donner à une fonction utilisateur le même nom qu'une fonction prédéfinie ou qu'une autre fonction utilisateur. Notez que si chaque script PHP "connaît" toutes les fonctions PHP prédéfinies, les fonctions utilisateur ne sont connues que dans les seuls scripts où elles sont déclarées. Par conséquent, rien ne vous empêche de réutiliser le nom d'une de vos fonctions utilisateur pour l'attribuer à une autre fonction, stockée dans un autre fichier. Cette pratique est toutefois source de confusion, et devrait être évitée.

Les différents noms qui suivent sont tous légaux :

Petite_Main.gif  nom()

Petite_Main.gif  nom2()

Petite_Main.gif  nom_trois()

Petite_Main.gif  _nomquatre()

Petite_Main.gif  _nom_cinq()

Tandis que ceux-ci sont illégaux :

Petite_Main.gif  10nom()

Petite_Main.gif  nom-sept()

Petite_Main.gif  fopen()

(Le dernier de ces noms aurait été légal s'il n'était déjà attribué à une fonction prédéfinie.)

Paramètres :

Pour accomplir la tâche pour laquelle elles ont été conçues, la plupart des fonctions requièrent que un ou plusieurs paramètres (arguments) leur soient fournis. Un paramètre permet de passer des données à une fonction. Voici un exemple d'une fonction qui prend un tableau unidimensionnel comme paramètre, et l'affiche sous une forme tabulaire :

    <?PHP

        function create_table($data)

          {

       echo " <BR /> <CENTER> <TABLE BORDER = '2'> " ;

     reset($data) ; // Souvenez-vous que cette fonction permet de pointer le début des données.

     $value = current($data) ;

     while($value)

          {

       echo "<tr> <td> $value </td> </tr> \n" ;

     $value = next ($data) ;

          }

       echo "</CENTER> </TABLE>" ;

          }

Si la fonction create_table() est invoquée de la manière suivante :

    $mon_tableau = array("Ligne une." , "Ligne deux." , "Ligne trois." , "Ligne quatre.") ;

    create_table($mon_tableau) ;

    ?>

Alors le résultat obtenu, est celui montré ci-après : pour visualiser l'aperçu, en cliquant ici. [Exemple 1].

En utilisant un paramètre pour la fonction create_table(), nous avons pu manipuler au sein de cette dernière des données créées hors de la fonction (en l'occurence le tableau $data).

Tout comme les fonctions prédéfinies, les fonctions définies par l'utilisateur peuvent prendre plusieurs paramètres, et peuvent également prendre des paramètres optionnels. La fonction create_table() peut être améliorée de diverses manières, par exemple, en permettant à celui qui l'invoque de spécifier la bordure ou d'autres attributs du tableau. Voici un exemple d'une version améliorée de la fonction create_table(), très semblable à la précédente, si ce n'est qu'elle permet d'ajuster, optionnellement, la largeur de la bordure, l'espacement entre les cellules et l'espacement entre le contenu des cellules et la bordure :

    <?PHP

        function amelioration_tableau ($data, $border = 2, $cellpadding = 6, $cellspacing = 6)

          {

       echo " <BR /> <CENTER> <TABLE BORDER = $border cellpadding = $cellpadding "

        . " cellspacing = $cellspacing /> " ;

     reset($data) ; // Souvenez-vous que cette fonction permet de pointer le début des données.

     $value = current($data) ;

     while($value)

          {

       echo "<tr> <td> $value </td> </tr> \n" ;

     $value = next ($data) ;

          }

       echo "</CENTER> </TABLE>" ;

          }

    $mon_tableau = array("Ligne une." , "Ligne deux." , "Ligne trois." , "Ligne quatre.") ;

    amelioration_tableau ($mon_tableau) ; // Appel de la fonction amelioration_tableau().

    ?>

Le résultat obtenu, est celui montré ci-après : pour visualiser l'aperçu, en cliquant ici. [Exemple 2].

Le premier paramètre de la fonction amelioration_tableau() est obligatoire, comme dans le cas de la fonction create_table() de l'exemple précédent. Les trois paramètres suivants sont optionnels, parce que des valeurs par défaut sont spécifiées pour ces paramètres dans la déclaration de la fonction. L'appel de la fonction amelioration_tableau() peut produire un résultat comparable à celui de [l'exemple 1] précédent, s'il est formulé de la manière suivante :

    amelioration_tableau ($mon_tableau) ;

Pour une présentation plus aérée des données du tableau. Nous pourrions invoquer amelioration_tableau() de la manière suivante :

    amelioration_tableau ($mon_tableau, 5, 8, 8) ; // Appel de la fonction amelioration_tableau().

Lorsque des paramètres sont optionnels, il n'est pas indispensable d'en fournir des valeurs. L'interpréteur PHP affecte les paramètres de gauche à droite.

Notez bien qu'il n'est pas possible de "sauter" un paramètre optionnel lors d'un appel de fonction, pour spécifier un autre paramètre optionnel venant à sa droite dans la définition de la fonction. Dans l'exemple considéré ici, il est nécessaire de passer une valeur pour le paramètre cellpadding pour pouvoir passer une valeur pour le paramètre cellspacing. Le non-respect de cette règle est à l'origine de nombreuses erreurs de programmation. Par ailleurs, cette règle est la raison pour laquelle les paramètres optionnels sont toujours spécifiés en dernier dans la liste des paramètres.

L'appel de fonction suivant :

    amelioration_tableau ($mon_tableau, 5) ;

Est tout à fait légal, et conduit à une bordure large de 5 pixels et à des espacements entre cellules et au sein des cellules ajustés sur les valeurs par défaut.

Portée d'une variable :

Vous avez peut-être noté, dans certains exemples de cette leçon ou des chapitres précédents, que lorsque des variables sont nécessaires dans du code enregistré dans un fichier chargé via une instruction require() ou include(), nous les déclarons simplement dans le script avant l'instruction require() ou include(). Par contre, avec une fonction, les variables requises au sein de la fonction doivent être explicitement passées à la fonction sous forme de paramètres. Cette différence s'explique en partie, par le fait qu'il n'existe pas de mécanisme permettant de passer explicitement des variables à des fichiers de type "include", et en partie parce que la portée d'une variable est différente dans le contexte d'une fonction.

La portée d'une variable définit les emplacements du code où une variable est visible et utilisable. Chaque langage de programmation peut avoir ses propres règles, en matière de portée des variables. Les règles du langage PHP sont relativement simples sur ce point :

Petite_Main.gif  La portée d'une variable déclarée au sein d'une fonction s'étend de l'instruction à partir de laquelle est déclarée la variable jusqu'à l'accolade de fermeture de la fonction. La portée est alors dite "limitée à la fonction, et les variables sont qualifiées de "locales".

Petite_Main.gif  La portée d'une variable déclarée hors d'une fonction s'étend de l'instruction dans laquelle la variable a été déclarée jusqu'à la fin du fichier, exception faite des fonctions. La portée est alors "globale", et les variables elles-mêmes sont qualifiées de globales.

Petite_Main.gif  L'usage d'instructions require() et include() n'affecte pas la portée des variables. Si une telle instruction est mise en œuvre au sein d'une fonction, la portée est limitée à la fonction. Si une instruction require() ou include() est mise en œuvre hors de toute fonction, la portée est globale.

Petite_Main.gif  Le mot clé global peut être employé pour spécifier explicitement qu'une variable définie ou utilisée au sein d'une fonction doit avoir une portée globale.

Petite_Main.gif  Une variable peut être supprimée explicitement via un appel de la fonction unset ($nom_variable). Après qu'une variable a été traitée par la fonction unset(), la portée de la variable n'est plus définie.

Les quelques exemples qui suivent vous aideront à mieux saisir les implications de ces règles.

L'exécution du code donné ci-dessous ne produit aucun résultat. Une variable appelée $var y est déclarée au sein d'une fonction dénommée fonc(). Parce que cette variable est déclarée au sein d'une fonction fn() par exemple, sa portée est limitée à la fonction, et elle existe seulement entre le point où elle a été déclarée et la fin de la fonction. Lorsque $var est mise en œuvre hors de la fonction fn(), l'interpréteur PHP crée une nouvelle variable appelée $var. Cette nouvelle variable est de portée globale, et reste visible jusqu'à la fin du fichier. Comme $var est uniquement utilisée dans une simple instruction echo, elle ne stocke aucune valeur.

    function fn()

       {

          $var = " Je suis parti ! " ;

       }

    echo $var ;

Voici la situation inverse : une variable est déclarée hors d'une fonction fn(), et nous tentons de l'utiliser au sein de la fonction fn().

    function fn()

       {

    echo " Je suis à l'intérieur de la fonction, \$var = " . $var . " <BR /> " ;

    $var = " Je suis parti (2) " ; // Variable locale.

    echo " Je suis à l'intérieur de la fonction, \$var = " . $var . " <BR /> " ;

       }

    $var = " Je suis parti (1) " ; // Variable portée globale

    fn() ; // On fait appel à la fonction.

    echo " Je suis en dehors de la fonction, \$var = " . $var . " <BR /> " ;

L'exécution de ce fragment de code conduit au résultat suivant :

     Je suis à l'intérieur de la fonction, $var =

     Je suis à l'intérieur de la fonction, $var = Je suis parti (2)

     Je suis en dehors de la fonction, $var = Je suis parti (1)

Les fonctions n'étant exécutées que lorsqu'elles sont appelées, la première instruction exécutée dans ce code est $var = " Je suis parti (1) " ;. Une variable appelée $var est alors créée. Cette variable est de portée globale, et contient la chaîne "Je suis parti (1)". L'interpréteur PHP exécute ensuite l'appel de la fonction fn(), en exécutant dans l'ordre les lignes qui constituent la déclaration de la fonction. La première de ces lignes fait référence à une variable dénommée $var. Au moment de l'exécution de cette ligne, l'interpréteur PHP ignore la variable $var déjà créée, et crée une nouvelle variable dont la portée se limite à la fonction fn(). C'est l'affichage du contenu de cette nouvelle variable au moyen de l'instruction echo qui produit la première ligne dans la fenêtre du navigateur.

La ligne qui vient ensuite dans la déclaration de la fonction donne à $var le contenu " Je suis parti (2) ". Etant donné que cette ligne de code appartient à la fonction, elle modifie la valeur de la variable $var locale, et non pas celle de la variable globale. La deuxième ligne affichée dans le navigateur met en évidence ce fonctionnement.

Une fois que s'achève l'exécution de la fonction, la dernière ligne de notre petit script est exécutée. Cette instruction echo finale montre que la valeur de la variable globale $var n'a pas été affectée par l'exécution de la fonction fn()

Pour obtenir qu'une variable créée au sein d'une fonction soit de portée globale, nous devons spécifier le mot clé global, comme suit :

    function fn()

       {

    global $var ;

    $var = " Je suis parti " ; // Variable globale.

    echo " Je suis à l'intérieur de la fonction, \$var = " . $var . " <BR /> " ;

       }

    fn() ; // On fait appel à la fonction.

    echo " Je suis en dehors de la fonction, \$var = " . $var . " <BR /> " ;

Dans cet exemple, la variable $var est explicitement définie comme globale. Il s'ensuit que, après l'appel de la fonction fn(), la variable persite hors de la fonction. L'exécution de ce fragment de code produit l'affichage suivant :

     Je suis à l'intérieur de la fonction, $var = Je suis parti

     Je suis en dehors de la fonction, $var = Je suis parti

Notez bien que la portée de la variable commence au point où la ligne global $var ; est exécutée. Nous aurions aussi bien pu placer la déclaration de la fonction après qu'avant la ligne contenant l'appel de la fonction. Une déclaration de fonction peut être indifféremment placée, en n'importe quel point d'un script. Par contre, la position de l'appel de la fonction est importante, puisqu'elle définit l'endroit du script où est exécutée la fonction.

Le mot clé global peut également être spécifié en début de script, à la première utilisation d'une variable, de sorte à indiquer à l'interpréteur PHP que la variable doit être de portée globale. Cet usage du mot clé global est probablement le plus courant.

Les exemples précédents montrent bien qu'il est parfaitement légal de réutiliser un nom de variable, pour des variables déclarées hors et au sein d'une fonction, sans interférence entre les variables de même nom. Cette pratique est toutefois déconseillée, parce qu'elle est source de confusion.

Pour l'instant, nous terminons ce deuxième chapitre et nous verrons dans le prochain, l'usage de Passer par référence contre passer par valeur ainsi que la Sortie forcée d'une fonction et Renvoie de valeurs par des fonctions.



  Cliquez ici pour la leçon suivante ou dans le sommaire prévu à cet effet.   Haut de page
  Page précédente   Page suivante







Nombre de pages vues, à partir de cette date : le 23 MAI 2019

compteur de visite

    




Envoyez un courrier électronique à Administrateur Web Société pour toute question ou remarque concernant ce site Web. 

Version du site : 10. 5. 14 - Site optimisation 1280 x 1024 pixels - Faculté de Nanterre - Dernière modification : 19 MAI 2019.   

Ce site Web a été Créé le, 14 Mars 1999 et ayant Rénové, en MAI 2019.