Une fonction peut être résumée à un sous-programme que l'on appelle depuis le programme principal.
PHP possède de nombreuses fonctions intégrées permettant d'effectuer des actions courantes. Toutefois, il est possible de définir ses propres fonctions afin de simplifier l'exécution de séries d'instructions répétitives, ce qui simplifie le code, et facilite sa mise à jour.

1- Déclaration d'une fonction

La définition d'une fonction s'appelle déclaration et peut se faire n'importe où dans le code grâce au mot-clé function.

function Nom_De_La_Fonction(type1 argument1, type2 argument2, ...) {
liste d'instructions
}

Les arguments sont les paramètres que l'on passe à la fonction. Il peut y en avoir un, plusieurs, ou même aucun (dans ce cas, on laisse les parenthèses vides). Les arguments peuvent être de simple variables, mais aussi des tableaux ou des objets. A noter qu'il est possible de donner une valeur par défaut à ces arguments.

La fonction peut renvoyer une valeur grâce au mot-clé return. Lorsque l'instruction return est rencontrée, la valeur de retour est envoyée au programme appelant et la fonction stoppée. Une fonction peut contenir plusieurs instructions return.

  1. <?php
  2.  
  3. function dire_texte($qui, $texte = 'Bonjour')
  4. {
  5.  
  6.  if(empty($qui)){ // $qui est vide, on retourne faux
  7.   return false;
  8.  }else{
  9.   echo $texte . ' ' . $qui; // on affiche le texte
  10.   return true; // fonction exécutée avec succès
  11.  }
  12.  
  13. }
  14.  
  15. ?>

2- Appel de fonction

Pour exécuter une fonction, il suffit de faire appel à elle en lui passant les paramètres nécessaires.

Nom_De_La_Fonction(type1 argument1, type2 argument2, ...);

Certains arguments peuvent être optionnels, lorsqu' une valeur par défaut leur a été donnée. Dans l'exemple précédent, $qui est obligatoire, alors que $texte est optionnel.

  1. <?
  2.  
  3. // Passage des deux paramètres
  4. dire_texte("cher phpeur", "Bienvenue"); // affiche "Bienvenue cher phpeur"
  5.  
  6. // Utilisation de la valeur par défaut du deuxième paramètre
  7. dire_texte("cher phpeur"); // affiche "Bonjour cher phpeur"
  8.  
  9. ?>

En utilisant la valeur de retour :

  1. <?
  2.  
  3. // Utilisation de la valeur de retour
  4. if(!dire_texte("")){ // provoque l'affichage ci dessous
  5.  echo "Erreur"; // puisque la chaine passée est vide la fonction retourne false
  6. }
  7.  
  8. if(!dire_texte("cher phpeur")){ // affiche "Bonjour cher phpeur"
  9.  echo "Erreur"; // ne s'affiche pas
  10. }
  11.  
  12. ?>

3- Précisions

Les variables locales et globales

Les variables extérieures à une fonction ne sont pas disponibles dans une fonction et, vice-versa (les variables utilisées dans une fonction ne sont pas répercutées à l'extérieur de la fonction). Une variable a donc une portée plus ou moins grande selon l'endroit où elle est définie.

Il existe plusieurs niveaux de définition de variable :

  • Le niveau global, qui permet à une variable d'être visible dans la fonction et à l'extérieur de la fonction.
  • Le niveau static permet de définir une variable locale à la fonction, qui persiste durant tout le temps d'exécution du script.
  • Le niveau local, utilisé par défaut, permet de définir une variable locale classique.
  1. <?php
  2.  
  3. $chaine = 'Nombre de camions : ';
  4.  
  5. function ajoute_camion($mode = '')
  6. {
  7.  
  8.  global $chaine;
  9.  static $nb = 0;
  10.  
  11.   $nb++; // on incrémente le nombre de camions
  12.  
  13.  if($mode == "affiche")
  14.  {
  15.   echo $chaine . $nb; // on affiche le nombre de camions
  16.  }
  17.  
  18. }
  19.  
  20. ajoute_camion(); // nb == 1
  21. ajoute_camion(); // nb == 2
  22. ajoute_camion(); // nb == 3
  23. ajoute_camion("affiche"); // affiche Nombre de camions : 4
  24.  
  25. ?>

Passage par référence

Dans les exemples précédents, nous avons vu comment passer des arguments à une fonction, nous avons utilisé le passage par valeur. Autrement dit, nous passions la valeur de la variable à la fonction.

Il existe une autre solution : le passage par référence. Dans ce cas, on passe la référence (adresse mémoire) de la variable à la fonction, ce qui permet de modifier sa valeur. Pour cela, il suffit simplement d'ajouter le signe "&" devant le paramètre de la fonction.

  1. <?php
  2.  
  3. function dire_texte($qui, &$texte)
  4. {
  5.  
  6.  $texte = "Bienvenue $qui";
  7.  
  8. }
  9.  
  10. $chaine = "Bonjour ";
  11. dire_texte("cher phpeur", $chaine);
  12. echo $chaine; // affiche "Bienvenue cher phpeur"
  13.  
  14. ?>

Retourner plusieurs valeurs

Lorsque vous souhaitez qu'une fonction retourne plusieurs valeurs, le plus simple est d'utiliser un tableau.

  1. <?php
  2.  
  3. function nom_fonction()
  4. {
  5.  
  6. .....
  7.  
  8. return array( $variable1, $variable2, $variable3 ); // on retourne les valeurs voulues dans un tableau
  9.  
  10. }
  11.  
  12. $retour = nom_fonction();
  13. echo "$retour[0] - $retour[1] - $retour[2]";
  14.  
  15. ?>

Fonctions récursives

Les fonctions récursives sont des fonctions qui s'appellent elles-mêmes. Ce type de fonction se révèle indispensable pour parcourir une arborescence par exemple.

Prenons un exemple simple :

  1. <?php
  2.  
  3. function fonction_recursive($n=0)
  4. {
  5.  
  6.  $n++;
  7.  echo "$n <br />";
  8.  if($n < 10){ // si n est inférieur à 10 on continue
  9.   fonction_recursive($n);
  10.  }
  11.  
  12. }
  13.  
  14. fonction_recursive(); // affiche les nb de 1 à 10
  15.  
  16. ?>