Fonctions Personnelles

Le PHP permet de créer ses propres fonctions.

DéfinitionDéclaration

Déclaration d'une fonction

1
function nom_fonction($a, $b) // a et b sont des paramètres
2
{
3
  $c = $a + $b;
4
  return $c; // valeur renvoyée (facultatif)
5
}

Exemple :

1
function plusGrand($a, $b) // a et b sont des paramètres
2
{
3
  if($a > $b){
4
    return $a;
5
  } else {
6
    return $b;
7
  }
8
}
9
echo plusGrand(12, 34); // retourne 34
10
echo "<br />";
11
echo plusGrand(15, 3); // retourne 15
Fonction

DéfinitionParamètres optionnels

Certains paramètres peuvent ne pas être passés. Une valeur par défaut est fournie lors de la déclaration.

1
function nom_fonction($a, $b=5) // b est un paramètre optionnel
2
{
3
  return $a + $b;
4
}
5
echo nom_fonction(2, 3); // $a=2 et $b=3 retourne 5
6
echo "<br />";
7
echo nom_fonction(2); // $a=2 et $b=5 retourne 7
Fonction

DéfinitionVariable locale

Les variables déclarées dans vos scripts ne sont pas accessibles dans vos fonctions et inversement.

1
$a = 5;
2
function maFonction()
3
{
4
  $b = 3;
5
  echo $a; // affiche variable a non définie
6
  echo $b; // affiche 3
7
}
8
maFonction();
9
echo "<br />";
10
echo $a; // affiche 5
11
echo $b; // affiche variable b non définie
Fonction

DéfinitionVariable globale

Les variables déclarées dans vos scripts peuvent être accessibles dans vos fonctions à condition d'être déclarées avec le mot-clé global dans celles-ci.

1
$a = 5;
2
function maFonction()
3
{
4
  global $a; // $a est le $a du script
5
  $b = 3;
6
  echo $a; // affiche 5
7
  echo "<br />";
8
  echo $b; // affiche 3
9
  $a = 8; // modifie $ global
10
}
11
maFonction();
12
echo "<br />";
13
echo $a; // affiche 8
14
echo "<br />";
15
echo $b; // affiche variable b non définie
Fonction

L'utilisation du mot-clé global est à éviter, car il vous rend dépendant d'une variable créée en dehors de votre fonction.

Un site pouvant être réalisé à plusieurs, vous n'êtes pas à l'abri d'une modification du contenu de votre variable.

Si vous avez besoin d'une information venant de l'extérieur : ajoutez un paramètre.

DéfinitionVariable static

Les variables d'une fonction sont réinitialisées à chaque appel de cette fonction.

Si l'on veut conserver la valeur précédente, il faut déclarer la variable comme static.

1
function maFonction()
2
{
3
  static $b=0;
4
  $b++;
5
  echo $b;
6
  echo "<br />";
7
}
8
maFonction(); // affiche 1
9
maFonction(); // affiche 2
Fonction

DéfinitionValeur ou référence

Par défaut, lorsque vous transmettez des paramètres à une fonction, vous ne lui envoyé que sa valeur.

C'est à dire, que vous transmettez un copie de votre variable. Si la fonction modifie la copie, la variable originale reste inchangée.

1
$a = 3;
2
function maFonction($b)
3
{
4
  $b++;
5
  echo $b;
6
}
7
maFonction($a); // affiche 4
8
echo "<br />";
9
echo $a;        // affiche 3
Fonction

Il est toutefois possible de faire en sorte que la variable soit réellement modifiée.

C'est ce que l'on appelle un passage par référence. Pour cela, le paramètre concerné doit être précédé d'un & lors de sa déclaration.

Cette fois ci, nous transmettons à la fonction la variable originale.

1
$a = 3;
2
function maFonction(&$b)
3
{
4
  $b++;
5
  echo $b;
6
}
7
maFonction($a); // affiche 4
8
echo "<br />";
9
echo $a;        // affiche 4
Fonction

Dans le premier cas, $b a copié le contenu de $a. Dans le deuxième, $a et $b représentent la même case mémoire.

DéfinitionNombre de paramètres indéfinis

Il est possible de déclarer des fonctions sans préciser le nombre de paramètres.

Pour cela, on utilise l'opérateur de décomposition ... suivi du nom de la variable qui contiendra sous forme de tableau l'ensemble des données.

1
function maFonction(...$listeValeurs)
2
{
3
  $somme = 0;
4
  foreach($listeValeurs as $valeur) $somme += $valeur;
5
  return "la somme est de $somme";
6
}
7
echo maFonction(1,2,3,4,5); // affiche la somme est de 15
Fonction

DéfinitionTypage des paramètres

Il est possible de typer les paramètres et le retour de la fonction.

1
function maFonction(int $a, int $b): float
2
{
3
  return $a / $b;
4
}
5
echo maFonction(1,2); // affiche 0.5
6
echo "<br />";
7
echo maFonction("a",2); // affiche Erreur fatale
Fonction

Liste des Types :

  • array : tableau

  • callable : fonction de rappelle

  • bool : booléen

  • float : nombre flottant

  • int : entier

  • string : chaîne de caractères

  • object : un objet.

  • nom d'une classe

  • self : dans les méthodes de classe, retour de l'instance

Le typage permet un débogage du code plus rapide. En effet, si vous ne transmettez pas le bon type de paramètre à votre fonction, ou si elle ne retourne pas le bon type, une erreur se déclenchera immédiatement au niveau de la fonction. Sinon, vous pourriez avoir une cascade d'erreurs non détectés et retournant un résultat faux.

Exemple de détection tardive :

1
function concatenation($nb1, $nb2)
2
{
3
    return $nb1 . $nb2;
4
}
5
6
function somme($a, $b)
7
{
8
    return $a + $b;
9
}
10
echo somme(concatenation(1,2), concatenation(2,3));
11
echo somme(concatenation(1,'a'), concatenation(2,3));
Dans notre exemple, la fonction concatenation permet d'assembler deux nombres pour n'en faire qu'un sous forme de chaîne de caractères.
On utilise la fonction somme pour additionner ces deux chaînes de caractères. Ce qui n'est possible que si la chaîne de caractères ne contient que des nombres.
Le premier echo nous retourne "35"
Le deuxième, nous dit qu'il y a une erreur fatal dans la fonction somme : Unsupported operand types: string + string
L'erreur d'origine est en réalité le fait que le paramètre $nb2 n'est pas un nombre.
1
function concatenation(int $nb1, int $nb2): string
2
{
3
    return $nb1 . $nb2;
4
}
5
6
function somme(string $a, string $b): int
7
{
8
    return $a + $b;
9
}
10
echo somme(concatenation(1,2), concatenation(2,3));
11
echo somme(concatenation(1,'a'), concatenation(2,3));
En ajoutant le typage, l'erreur est détecté au bon endroit : Uncaught TypeError: concatenation(): Argument #1 ($nb2) must be of type int, string given
DéfinitionFonctions anonymes
Comme son nom l'indique, une fonction anonyme est une fonction qui n'a pas de nom.
Elles sont aussi appelées fermetures ou closures.
On peut les utiliser comme paramètre de fonction. Leur type est callable :
1
function maFonction(int $a, int $b, callable $fn): string
2
{
3
  return "Le résultat est : " . $fn($a, $b);
4
}
5
echo maFonction(2,3, function($a,$b){return $a+$b;}); // affiche : Le résultat est 5
6
echo maFonction(2,3, function($a,$b){return $a*$b;}); // affiche : Le résultat est 6
Fonction
Pour ajouter des variables du contexte du parent qui n'ont pas été prévues dans les arguments, on utilise le mot clé use.
1
$a = 2;
2
$b = 3;
3
function maFonction(callable $fn): string
4
{
5
  return "Le résultat est : " . $fn();
6
}
7
echo maFonction(function() use ($a, $b) {return $a+$b;}); // affiche : Le résultat est 5
8
echo maFonction(function() use ($a, $b) {return $a*$b;}); // affiche : Le résultat est 6
Fonction
DéfinitionFonctions fléchées
Les fonctions fléchée permettent une écriture simplifiée de certaines fonctions anonymes.
1
// fonction anonyme
2
$fonctionAnonyme = function ($a) { return $a;}
3
echo $fonctionAnonyme(5); // 5
4
5
// fonction fléchée
6
$fonctionFlechee = fn($a) => $a;
7
echo $fonctionFlechee(5); // 5
Pas d'accolades, pas de return.
Elles peuvent utiliser les variables du contexte parent sans le préciser :
1
$b = 2;
2
// fonction anonyme
3
$fonctionAnonyme = function ($a) use ($b) {return $a + $b;};
4
echo $fonctionAnonyme(5); // 7
5
6
// fonction fléchée
7
$fonctionFlechee = fn ($a) => $a + $b;
8
echo $fonctionFlechee(5); // 7