Fonction Utilisateur

Les Fonctions Utilisateur

Qu'est-ce qu'une fonction utilisateur ?
Une fonction est un morceau de code permettant d'automatiser un traitement ou de donner un affichage particulier.
Cela permet également de ré-utiliser un morceau de code à plusieurs reprises.

Imaginez la problématique suivante :
Vous souhaitez calculer votre imposition, cela vous demande plusieurs lignes de calcul, de la réflexion et vous finissez par y parvenir.
Ensuite, vous devrez reprendre ces lignes chaque année puisque l'imposition est annuelle.
Plutôt qu'effectuer un copier/coller, il serait judicieux d'enfermer votre calcul dans une fonction que vous pourrez rappeler à tout moment lorsque vous en aurez envie.

D'autre part, votre situation peut changer, vous vous mariez et avez des enfants, le calcul d'imposition n'est plus le même (car vous avez le droit a des abatements).
Plutôt que modifier le coeur de votre calcul, vous pourriez ajouter ce que l'on appelle des paramètres (ou arguments). Ce sont des informations variables qui peuvent venir modifier le comportement initialement prévu par la fonction ou bien compléter son traitement.

De cette manière votre fonction sera adaptée à tout le monde et à toutes les situations possibles (marié ou célibataire, avec ou sans enfants), pour l'appliquer il faudra juste le préciser au moment d'exécuter la fonction.

A l'inverse des fonctions prédéfinies (qui sont déjà prévues par le langage), c'est à nous d'écrire nos propres fonctions spécifiques (lorsqu'aucune fonction de la documentation peut nous convenir).

Cela pourrait s'appeler fonction développeur.

Créons notre première fonction pour calculer une TVA

Prenons le contexte d'un site ecommerce qui aura besoin d'ajouter la TVA sur ses produits.

Déclarons notre première fonction pour calculer la TVA sur 100 € :

	<?php	
	// déclaration d'une fonction
	function calculTva()
	{
		return 100*1.2;
	}
	
	// exécution de notre fonction
	echo calculTva() . '
';

Explications

Pour déclarer une fonction, nous utilisons le mot-clé function et ensuite nous lui donnons un nom (sans espace, ni accent), ici elle s'appelle : calculTva.

Les parenthèses permettent de préciser s'il y a des arguments entrants, ce n'est pas notre cas, notre fonction est donc destinée à ne pas recevoir d'arguments.

Les accolades définissent le périmètre de la fonction. A l'intérieur des accolades nous pouvons écrire des lignes de traitement PHP (ces lignes feront partie de la fonction).

le mot-clé return est utilisé pour retourner un résultat. Il est en général placé à la fin pour terminer la fonction.

Le calcul 120*1.2 (100 multiplié par 1, puis 0.2 fait bien 120). 1.2 correspond bien à 20 % (la TVA Française la plus courante en vigueur).

Créons une fonction avec un argument pour faire plus de calculs

Le site ecommerce (que nous avons pris comme sujet) ne vendra pas que des produits à 100 €.
Nous allons améliorer notre fonction afin de pouvoir effectuer tous les calculs et non pas que sur un nombre fixe de 100 €.
Pour cela nous allons avoir besoin d'un argument entrant (le prix, ici appelée $nombre) :

	<?php	
	// déclaration d'une fonction
	function calculTva2($nombre)
	{
		return $nombre*1.2;
	}
	
	// exécution de notre fonction
	echo calculTva2(500) . '
';
	echo calculTva2(1000) . '
';

Explications

Cette fois-ci, dans les parenthèses de notre déclaration de fonction, nous avons prévu une variable nommée $nombre, cette variable pourrait très bien être nommée $x ou $y. Peu importe tant qu'il y'a une variable de réception de prévue. J'ai choisi de la nommer $nombre car c'est plus cohérent avec le sujet.

Le calcul a également changé, ce n'est plus 100*1.2 car ce calcul est fixe et donne toujours le même résultat. Cette fois-ci nous allons calculer 20% sur le nombre que nous allons recevoir $nombre*1.2, et il peut donc changer à tout moment.

En effet, une fonction est déclarée une fois mais peut être exécutée autant de fois que nécessaire.

Dans notre cas nous réalisons une première exécution :

echo calculTva2(500) . '
';

Ce qui donne comme calcul : 500 * 1.2 = 600 €

Et, une deuxième exécution :

echo calculTva2(1000) . '
';

Ce qui donne comme calcul : 1000 * 1.2 = 1200 €

La fonction a été renommée en calculTva2 pour éviter tout conflit avec la 1ère fonction calculTva si vous l'aviez gardée présente dans le même fichier.
En effet, nous ne pouvons pas déclarer 2 fonctions du même nom au sein du même fichier au risque d'avoir une erreur du type : Fatal error: Cannot redeclare ... (previously declared in ...) on line ...

Ce message d'erreur précise l'endroit de la 1ère déclaration afin que vous puissiez faire un choix entre garder la première, ou la deuxième ou éventuellement fusionner les deux.

Au moment de la déclaration, lorsqu'une fonction est destinée à recevoir 1 argument, vous devrez obligatoirement lui envoyer 1 argument au moment de l'exécution au risque d'avoir une erreur du type : Warning: Missing argument ... for ...()

Pour une meilleure compréhension, voici le chemin parcouru par l'argument :

Créons une fonction avec un argument pour faire tous les calculs possibles

Dans notre précédente fonction utilisateur, nous pouvions calculer la TVA de nimporte quel nombre mais pas avec nimporte quel taux de TVA.
Nous allons améliorer notre fonction afin de pouvoir effectuer tous les calculs sur tous les nombres et sur tous les taux de TVA
Nous allons avoir besoin de deux arguments entrants :

	<?php	
	// déclaration d'une fonction
	function calculTva3($nombre, $taux)
	{
		return $nombre*$taux;
	}
	
	// exécution de notre fonction
	echo "500 € avec un taux de 5.5 % font : " . calculTva3(500, 1.055) . '
';
	echo "1000 € avec un taux de 20 % font : "calculTva3(1000, 1.2) . '
';

Explications

Cette fois-ci, dans les parenthèses de notre déclaration de fonction, nous avons prévu deux variable nommées $nombre et $taux. Ce qui implique qu'il faudra transmettre 2 informations au moment de l'exécution.

Le calcul a également changé, c'est $nombre*$taux. Le nombre et le taux peuvent changer à tout moment.

Dans notre cas nous réalisons une première exécution :

echo calculTva3(500) . '
';

Ce qui donne comme calcul : 500 * 1.055 = 527.5 €

Et, une deuxième exécution :

echo calculTva3(1000) . '
';

Ce qui donne comme calcul : 1000 * 1.2 = 1200 €

La fonction a été renommée en calculTva3 pour éviter tout conflit avec la 1ère fonction calculTva et calculTva2 si vous l'aviez gardée présente dans le même fichier.
Au moment de la déclaration, lorsqu'une fonction est destinée à recevoir 2 arguments, vous devrez obligatoirement lui envoyer les 2 arguments au moment de l'exécution, ne l'oubliez pas !

Dans une fonction nous pouvons déclarer autant de receptions d'argument que l'on souhaite à condition de les transmettre au moment de l'exécution. Si le nombre d'arguments est conséquent, il est préférable de passer par une variable array.

Argument facultatif par défaut

Nous l'avons dit, si votre fonction est destinée a recevoir 1 argument c'est qu'il faut lui envoyer obligatoirement 1 argument, si elle est destinée a recevoir 2 arguments, il faut lui en envoyer 2 et ainsi de suite...
Toutefois, il est possible que votre fonction attende 2 arguments mais en déclarant l'un d'entre eux comme étant facultatif !
Pour rendre un argument facultatif, il faut absolument lui déclarer une valeur par défaut.

Reprenons notre calcul de TVA :

	<?php	
	// déclaration d'une fonction
	function calculTva4($nombre, $taux = 1.2)
	{
		return $nombre*$taux;
	}
	
	// exécution de notre fonction
	echo calculTva4(1500) . '
'; // exécution de la fonction avec 1 seul argument
	echo calculTva4(800, 1.07) . '
'; // exécution de la fonction avec 2 arguments

Explications

La première fois la fonction est exécutée avec un seul argument. C'est donc le taux de TVA par défaut 1.2 qui est pris en compte.

La seconde fois la fonction est exécutée avec deux arguments. et le taux 1.07 vient remplacer le taux par défaut (1.2) qui ne sera pas appliqué en présence d'un argument choisi.

On peux donc dire que nous avons une fonction destinée à recevoir 2 arguments, mais qu'1 seul peut suffire.

Si un seul argument est envoyé, le taux par défaut est appliqué soit 1.2 :

function calculTva4($nombre, $taux = 1.2)

En présence du 2e argument (lors de l'exécution) il est prioritaire et le taux par défaut (1.2) n'est pas appliqué.

calculTva4(800, 1.07)

Opérateurs Arithmétiques

Puisque nous parlons de calcul de TVA et de multiplications, voici ci-dessous quelques opérateurs arithmétiques

Dérrière ce mot impressionnant se cache simplement des additions, soustractions, multiplications et divisions que des élèves de ce2 pourraient faire :). C'est souvent comme ça en informatique, sont utilisés "certains mots qui font peur" ou qui font croire qu'il faut bac+5 pour les comprendre et les maitriser alors qu'avec des explications correctes il n'en est rien, du moment que c'est bien expliqué.

	<?php
	$a = 10 ; $b = 2 ;
	echo $a + $b . '
'; // affiche 12 (addition 10 + 2)

	echo $a - $b  . '
'; // affiche 8 (soustraction 10 - 2)

	echo $a * $b  . '
'; // affiche 20 (multiplication 10 * 2)

	echo $a / $b  . '
'; // affiche 5 (division 10 / 2) 
	
	echo $a % $b  . '
'; // affiche 0 (reste de la division 10 / 2) 

Jusque la, rien de bien difficile !

Nous pouvons aussi réaliser ces opérations en affectant une variable (dans la même exécution) :

	<?php
	$a += $b ; // équivaut à $a = $a + $b (ici $a vaut 12, voir ci-dessus)...10+2
	$a -= $b ; // équivaut à $a = $a - $b (ici $a vaut 12)...12-2

Explications :

$a += $b est pareil que $a = $a + $b
Cette notation de code peut être pratique lors d'un calcul sur un panier de site ecommerce.

Exercice fonction

Voici une simple fonction permettant de formuler une phrase au sujet de la météo :

	<?php
	meteo("hiver", 5); // il est possible d'exécuter une fonction avant qu'elle soit déclarée dans le code.
	function meteo($saison, $temperature) // 2 arguments attendus
	{
		echo "Nous sommes en $saison et il fait $temperature degrés
";
	}

Comme vous pouvez le constater, cette fonction attend 2 arguments, c'est la raison pour laquelle nous lui envoyons 2 arguments "hiver" et "5".


Imaginons que nous envoyons le chiffre 1 en 2e argument, cela afficherait "1 degrés" avec une faute de Français pour le "s", du coup notre exercice va être de gérer le pluriel et le singulier en fonction du nombre envoyé.

Exercice : pourriez-vous gérer le cas de la lettre S sur le mot degré en fonction du nombre envoyé ?

Pour 1 degré, cela doit s'écrire : 1 degré et non pas 1 degréS
Pour 2 degrés, cela doit s'écrire : 2 degrés et non pas 2 degré

Ne regardez pas la correction si vous souhaitez jouer le jeu

	<?php
	meteo("hiver", 1); // il est possible d'exécuter une fonction avant qu'elle soit déclarée dans le code.
	function meteo($saison, $temperature) // 2 arguments attendus
	{
		echo "Nous sommes en $saison et il fait $temperature";
		if($temperature > 1 || $temperature < -1) echo " degrés
";
		else  echo " degré
";
	}

Vous pouvez constater que lorsque nous écrivons un IF / ELSE avec une seule instruction à l'intérieur nous pouvons le mettre sur la même ligne sans accolades.

Cependant dans la majorité des cas, il est préférable de garder les accolades.

Attention, comme vous le savez le nombre d'arguments qu'attend une fonction est important, mais l'ordre des arguments l'est tout autant !
Voici un mauvais exemple avec l'inversion de l'ordre des arguments :

	<?php
	meteo(30, "été"); // il est possible d'exécuter une fonction avant qu'elle soit déclarée dans le code.
	function meteo($saison, $temperature) // 2 arguments attendus
	{
		echo "Nous sommes en $saison et il fait $temperature";
		if($temperature > 1 || $temperature < -1) echo " degrés
";
		else  echo " degré
";
	}

Cet exemple affichera :

Nous pouvons donc constater que le nombre et l'ordre des arguments sont vraiment importants !

Portée des variables : espace global et espace local

Ce chapitre risque d'être abstrait sur le coup mais très important et indispensable lors de la création d'un site web.
je vous recommande donc de suivre les explications. Concentrez-vous :)

Qu'est-ce qu'un espace local ?

Un espace local est le code déclaré à l'intérieur d'une fonction.
Exemple :

	<?php
	function affichageVille()
	{
		$ville = "Lyon"; // variable locale.
	}

On dit que la variable $ville est déclarée dans un espace local.

Qu'est-ce qu'un espace global ?

Un espace global est le code déclaré à l'extérieur d'une fonction (partout ailleurs).
Exemple :

	<?php
	function affichageVille()
	{
		// ...
	}
	
	$ville2 = "Marseille"

On dit que la variable $ville2 est déclarée dans l'espace global (espace par défaut).

Quelle est la différence entre 1 espace local et 1 espace global ?

Mieux qu'une succesion d'explications, voici une image qui représente parfaitement la chose :

Problématique avec l'espace local

	<?php
	function affichageVille()
	{
		$ville = "Lyon"; // variable locale.
	}
	affichageVille();
	echo $ville; // /!\ ne fonctionne pas car cette variable n'est connu qu'à l'intérieur de la fonction

Ce code ne fonctionnera pas, voici ce qu'il affichera :


Quelques Explications :

Ligne 1 : Nous déclarons une fonction affichageVille().
Ligne 3 : Nous déclarons une variable locale. variable locale = variable déclarée à l'intérieur d'une fonction.
Ligne 5 : Exécution de la fonction... (dans le vide)
Ligne 6 : Tentative d'affichage de la variable locale $ville déclarée à l'intérieur de la fonction.

Nous obtenons une erreur car en dehors de la fonction (au dessus et en dessous) nous sommes dans un espace global (c'est l'espace par défaut), alors qu'à l'intérieur de la fonction nous sommes dans un espace local.

Les informations de l'espace local ne sont pas connues dans l'espace global et vice-versa.

Comment véhiculer des informations de l'espace local vers l'espace global ?

Pour faire passer des informations déclarées dans l'espace local vers l'espace global, voici le code que nous pourrions mettre en oeuvre :

	<?php
	function affichageVille()
	{
		$ville = "Lyon"; // variable locale.
		return $ville; // une fonction peut retourner qqchose (à ce moment là on quitte la fonction)
		echo 'test'; // /!\ cette ligne ne s'affichera pas car il y a un return avant.
	}
	$villeRecu = affichageVille();
	echo $villeRecu;

Quelques Explications :

Ligne 1 : Nous déclarons une fonction affichageVille().
Ligne 3 : Nous déclarons une variable locale. variable locale = variable déclarée à l'intérieur d'une fonction.
Ligne 4 : Return permettra lors de l'exécution de la fonction, de retourner le contenu de la variable $ville (pour en avoir connaissance à l'extérieur de la fonction).
Ligne 5 : Ajout d'un echo qui n'a aucun rapport, juste pour montrer qu'après un return nous quittons la fonction et la suite du code n'est pas exécutée. Nous ne verrons pas le mot "test" s'afficher dans le résultat.
Ligne 7 : Nous récupérons l'exécution de la fonction dans une variable, la variable $villeRecu contiendra le contenu du return de la fonction affichageVile() c'est à dire "Lyon".
Ligne 8 : Nous affichons le contenu de la variable $villeRecu soit "Lyon".

En conclusion, nous pouvons donc dire que l'utilisation du mot-clé return permettra de faire passer des informations déclarées en local dans l'espace global.

Lorsque vous crérez une fonction perso, pensez à l'utilisation du mot-clé return pour préciser ce que votre fonction devra renvoyer !

Comment véhiculer des informations de l'espace global vers l'espace local ?

De la même manière, si les informations déclarées en local ne sont pas connues en global, nous retrouverons la même problématique dans l'autre sens (déclaration de variable en global et utilisation souhaitée en local).

Problématique avec l'espace global

	<?php
	$pays = 'France';
	function affichagePays()
	{
		echo $pays; // générera une erreur PHP.
	}
	affichagePays(); 

Quelques Explications :

Ligne 1 : Nous déclarons une variable $pays dans l'espace global (et oui nous sommes bien dans l'espace global puisque nous sommes à l'extérieur d'une fonction).
Ligne 2 : Déclaration d'une fonction utilisateur.
Ligne 4 : Affichage de la variable $pays.
Ligne 6 : Exécution de notre fonction affichagePays().
Suite à l'exécution de notre fonction affichagePays(), nous aurons une erreur sur la variable $pays qui apparaitra pour l'interpréteur comme étant indéfinie (undefined).
Cette erreur est normale dans la mesure où la variable est déclarée en global et on tente de l'afficher en local.

Pour faire passer des informations déclarées dans l'espace global vers un espace local (une fonction), voici le code que nous pourrions mettre en oeuvre :

	<?php
	$pays = 'France';
	function affichagePays()
	{
		global $pays; // importe la variable pays de l'espace global
		echo $pays;
	}
	affichagePays();

Quelques Explications :

Ligne 4 : Le mot-clé global permet d'importer une variable de l'espace global vers l'espace local, en l'ocurrence la variable $pays.

Nous aurions également pu envoyer $pays en argument à notre fonction.
Retenez bien que vous aurez besoin du mot-clé global lorsque vous aurez besoin de connaitre une variable dans une fonction.
Exemple : la connexion vers une base de données peut être représentée par une variable globale, et les requêtes SQL (permettant de récupérer des données) pourraient se trouver dans des fonctions locales, du coup il faudrait connaitre la connexion globale pour effectuer des requetes en local.

En conclusion, global permet d'importer des informations globales dans un espace local. return permet de sortir des informations locales dans l'espace global.