Cours PHP - leçon 7 - Fonctions PHP et programmation fonctionnelle

Je pense que nous sommes maintenant proches du moment où il est temps… temps de commencer à programmer. Après cette leçon, vous pourrez dire que vous avez programmé en PHP. Très souvent, il faut écrire du code qui doit être répété sur d’autres pages, dans d’autres fichiers .php. Pour ne pas dupliquer ce code, PHP offre les fonctions.

Une fonction est une partie indépendante du code qui effectue certains calculs. Nous avons rencontré des exemples de telles fonctions dans les leçons précédentes :

time() - fonction qui renvoie le nombre de secondes depuis le début de l’époque Unix.

print(), echo() - fonction permettant d’afficher du HTML.

floor() - fonction qui retourne la partie entière d’un nombre décimal.

Vous avez sans doute remarqué comment on désigne les fonctions : avec deux parenthèses (). La syntaxe générale d’une fonction est : nom_de_fonction(). Les règles de nommage sont les mêmes que pour les variables, sauf que pour les fonctions on n’utilise pas le signe dollar, mais on utilise les parenthèses.

Décomposons une fonction à l’aide d’un exemple :

<?php
function plus_one($x){  // définition de la fonction
  $x = $x + 1;          // corps de la fonction
  return $x;            // valeur renvoyée
}

$y = 1;
$y = plus_one($y);      // appel de la fonction
print $y;
?>

Le nom de la fonction est explicite : elle ajoute une unité à la variable. Voici les éléments qui composent une fonction :

Nom de la fonction

Le nom de la fonction doit respecter les règles suivantes :

1. Doit commencer par une lettre ou un underscore "_"
2. Peut contenir uniquement des lettres, chiffres et underscores (A-Z, a-z, 0-9, et _)
3. Ne doit pas contenir d’espaces. Si le nom comporte plusieurs mots, ils doivent être séparés par un underscore (ex : my_function()) ou utiliser la capitalisation camelCase (ex : myFunction())

Pour définir une fonction, on utilise le mot-clé function, qui indique que ce qui suit est un nom de fonction.

Corps de la fonction

C’est le code exécuté par la fonction. Dans notre exemple :

function plus_one($x){
  $x = $x + 1;  // corps de la fonction
  return $x;    // corps de la fonction
}

Le corps de la fonction est entouré d’accolades {}.

Valeur renvoyée

La valeur renvoyée est ce qui suit le mot-clé return. C’est le résultat de l’exécution de la fonction. Ici, nous renvoyons la valeur de la variable $x.

Paramètres de la fonction

Les paramètres sont des variables ou valeurs entre parenthèses après le nom de la fonction. Dans notre exemple, nous passons un seul paramètre $x, mais on peut en passer plusieurs, séparés par des virgules :

<?php
function myFunction($x1, $x2, $x3){

}

$y = myFunction($z, 34, 'Bonjour, monde !');
?>

Lorsque vous définissez une fonction, le nombre de paramètres indiqués est le nombre requis lors de l’appel. Si le nombre diffère, une erreur sera générée :

<?php
function myFunction($x1, $x2, $x3){

}

$y = myFunction(34, 'Bonjour, monde !'); // appel incorrect provoque une erreur !!!
?>

Notez que dans la définition, les noms des variables sont locaux à la fonction, tandis que lors de l’appel vous pouvez passer n’importe quelle valeur ou variable.

Voyons maintenant comment fonctionnent les fonctions PHP avec un exemple simple de fonction mathématique : y = -2x + 4. Trouvons les valeurs pour différentes valeurs de x.

<?php
function myFunction($x){
  $y = -2 * $x + 4;
  return $y;
}

$z1 = myFunction(1);
$z2 = myFunction(2);
$z3 = myFunction(3);
print $z1 . '<br />' . $z2 . '<br />' . $z3;
?>

Les résultats sont -2, 0, 2. Ce simple exemple devrait clarifier le fonctionnement des fonctions.

Parlons maintenant de la programmation fonctionnelle. Vous avez sans doute deviné pourquoi ce style s’appelle ainsi : parce que la programmation repose sur les fonctions, beaucoup de fonctions, des dizaines dans chaque fichier. Vous vous demandez comment gérer autant de fonctions ? La réponse est simple. Je vais expliquer avec un exemple :

<?php
function incr($x){
  $x++;
  return $x;
}

function decr($y){
  $y--;
  return $y;
}

$z = 0;
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = decr($z);
print $z;
?>

Comme dans l’exemple, on incrémente 4 fois puis on décrémente une fois. Le résultat est donc 3. Maintenant, plaçons les fonctions après le code :

<?php
$z = 0;
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = decr($z);
print $z;

function incr($x){
  $x++;
  return $x;
}

function decr($y){
  $y--;
  return $y;
}
?>

Le code produit toujours 3 car PHP reconnaît les fonctions où qu’elles soient dans le fichier. Mais que faire si vous avez 50, 100, ou 1000 fonctions ? La solution est de les organiser par fonctionnalité dans différents fichiers et dossiers. Créons deux fichiers :

decr.php :

<?php
function decr($y){
  $y--;
  return $y;
}
?>

incr.php :

<?php
function incr($x){
  $x++;
  return $x;
}
?>

Supprimez la définition des fonctions du fichier index.php car les redéfinir provoque une erreur. Si vous appelez une fonction non définie, vous aurez aussi une erreur. Soyez vigilant.

Incluez maintenant ces fichiers dans index.php :

<?php
include 'incr.php';
include 'decr.php';

$z = 0;
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = decr($z);
print $z;
?>

Vous pouvez ainsi utiliser le code des fichiers incr.php et decr.php sans alourdir index.php. Le résultat reste 3.

Ceci n’est qu’une introduction à la programmation fonctionnelle en PHP, nous approfondirons ce sujet dans les prochaines leçons.