Les fonctions
==============

.. code-block:: php

    Syntaxe :
		function <nomFonction> ($arg1, $arg2… ) {
				<instructions>;
		}

Une fonction « utilisateur » est un mini-programme. Les arguments sont les paramètres qu’on passe à la fonction. Il peut y en avoir 0, 1 ou plusieurs. Comme arguments, on peut passer des variables, des tableaux ou des objets.

Il est possible de donner une valeur par défaut à ces arguments: il suffit de faire comme une affectation dans la déclaration.

La déclaration d’une fonction peut avoir lieu n’importe où dans le code.

.. literalinclude:: file/boucle2.php
    :language: php

Les paramètres d’une fonction
------------------------------

* Peut y en avoir 0, 1 ou plusieurs
* Valeur par défaut possible (affectation dans la déclaration)‏
		=> Paramètre optionnel
* Paramètre passé par valeur (par copie), et pas par référence
* Possible de passer un paramètre par référence en indiquant un « & » devant le $parametre dans la déclaration de la fonction

.. literalinclude:: file/fonction1.php
	:language: php

Le fait de passer des paramètres par « valeur » signifie qu’on travaille sur une « copie » de la variable au sein de la fonction : si la valeur d’un paramètre est modifiée dans la fonction, elle est rétablie dès qu’on sort de la fonction.

Cet exemple nous montre un argument auquel on a fixé une valeur par défaut. De ce fait, il devient optionnel: on peut ne pas le spécifier dans l’appel de la fonction.

L’exemple nous montre également un appel à la fonction, sans même spécifier aucun paramètre: ceci provoque l’affichage d’un « warning message », qui ne sera affiché que dans le cas où le fichier php.ini l’autorise. En dehors de l’affichage de ce warning, le code fonctionne; cependant, ce n’est pas vraiment une bonne manière de programmer.

Enfin, remarquons le changement de valeur du paramètre $arg1 dans la fonction test. Comme le paramètre est passé par valeur, dès qu’on sort de la fonction, on retrouve la valeur originale de la variable.

Question : que se serait-il passé si la déclaration de la fonction avait été la suivante :

.. code-block:: php

	function test (&$arg1, $arg2 = "toto") {

Bien sûr, on ne peut déclarer qu’une fonction du même nom.

La valeur de retour d’une fonction
----------------------------------

* Mot-clef : return
* Après « return », la fonction s’arrête
* Retour de la valeur spécifiée
* Valeurs de retour renvoyées par « valeur » (par « copie »)‏
* Possible d’utiliser un retour par référence en indiquant un « & » devant le nom de la fonction dans sa déclaration
* Ne peut retourner qu’une seule valeur (mais on peut utiliser un tableau)‏

Dans cet exemple, nous avons repris le précédent pour l’adapter légèrement: la fonction test « retourne » une string, et c’est cette string que nous affichons.

.. literalinclude:: file/fonction2.php
	:language: php

Les paramètres indéfinis
------------------------

* Fonction aux paramètres non définis
		=> Pas de paramètres déclarés
* Mais on l’appelle en passant des paramètres
* Fonctions utiles :
	- func_num_args() : nombre de paramètres utilisés
	- func_get_args() : paramètres sous formes d’un tableau
	- func_get_arg($int) : paramètre dont l’index est « $int » (commence à 0)‏

.. literalinclude:: file/fonction3.php
	:language: php

**Exercice :**

Reprenez l’exercice précédent. Complétez votre programme par une fonction qui permet de connaître le type du fichier. La fonction prendra le nom du fichier en paramètre et rentra son type en retour (« texte », « image »…). Ce type sera affiché à côté du fichier dans la page HTML.

NB : voici une fonction utile :

.. code-block:: php

	pathinfo();

Inclure des fonctions « externes »
----------------------------------

* Possible d’inclure des bibliothèques (morceaux de code indépendants)‏
* Permet la réutilisation et la centralisation
* Inclusion = « copiage »
* Par convention, bibliothèque : .inc.php

**NB : Ceci reste du procédurale, nous utiliserons plus tard l'autoload de Composer par facilité.**

* Les fichiers à inclure sont d'abord recherchés dans le dossier désigné par include_path , relativement au dossier courant, puis dans include_path , relativement au dossier de travail du script. Par exemple, si include_path est . , que le dossier de travail est /www/ , et que vous incluez le fichier include/a.php et qu'il y a une instruction include "b.php" dans ce fichier, alors b.php est d'abord recherché dans /www/ , puis dans /www/include/ . Si le nom du fichier commence par ./ ou ../ , il est cherché uniquement dans l' include_path relatif au dossier courant d'exécution.
* Lorsqu'un fichier est inclus, le code le composant hérite de la portée des variables de la ligne où l'inclusion apparaît. Toutes les variables disponibles à cette ligne dans le fichier appelant seront disponibles dans le fichier appelé, à partir de ce point. Cependant, toutes les fonctions et classes définies dans le fichier inclu ont une portée globale.
* Si l'inclusion intervient à l'intérieure d'une fonction, le code inclus sera alors considéré comme faisant partie de la fonction. Cela modifie donc le contexte de variables accessibles.
* Comme include et require sont des structures du langage particulières, vous devez les placer dans un bloc s'ils sont placés dans un bloc conditionnel.

* 4 mots-clefs (structure de contrôle) :
	- include() : Si erreur => warning.
	- require() : Si erreur => fatal error.
	- include_once() : idem include(), mais s’assure que le fichier qu’on essaie d’inclure ne l’a pas déjà été
	- require_once() : idem require(), mais s’assure que le fichier qu’on essaie d’inclure ne l’a pas déjà été

.. literalinclude:: file/bibliotheque.php
	:language: php

.. literalinclude:: file/bibliotheque.inc.php
	:language: php