Les fonctions

Fonctions

Une fonction est un bloc de code auquel on a donné un nom afin de réutiliser ce dernier.

Une fonction ne réalise qu’un seul traitement. En PHP, il ne peut y avoir deux fonctions portant le même nom.

Syntaxe

	function nomFonction([ parametres (,) ]){
		//bloc de code
		[return valeur;]
	}

PHP peut accepter aucun parametre, les {} sont obligatoires et les fonctions d’affichages sont possibles.

Valeur de retour

Pour retourner une valeur, il faut spécifier le mot clé ‘return’. Dès quele mot clé est repéré, tout script suivant

ne sera pas exécuté. Lorsque la fonction ne possede pas de return ou que return est à blanc, la valeur de retour est nulle.

Cela sert à quitter la fonction

<?php
	/**
	* Fonction au carré
	* @param $x integer
	* @return integer|null
	*/
	function square($x)
	{
		if (!is_numeric($x))
			return ;
		echo 'Ok = ';
		return pow($x,2) ;
		//Ne sera PAS exécuté
		echo 'fin' ;
	}
	//return seul
	var_dump( square('cinq') ) ;

	//return + valeur
	var_dump( square(5) ) ;

Copie / Référence

Dans les fonctions, il est possible de passer des variables, soit par copie, soit par référence.

C’est l’opérateur ‘&’ qui permettra de passer les valeurs par référence.

	function &nomFonction() {

	}

Exemple :

	<?php
	/**
	* Fonction par référence
	*/
	function & returnRef()
	{
		static $a ;
		var_dump($a) ;
		return $a ;
	}

	$z	= & returnRef() ; // NULL
	$z	= 5;
	returnRef() ; // 5

	/**
	* Fonction par référence
	*/
	function returnCopy()
	{
		static $a ;
		var_dump($a) ;
		return $a ;
	}

	$z	= returnCopy() ; //NULL
	$z	= 5; //NULL
	returnCopy() ;

Les paramètres

Lorsqu’on appelle une fonction, il faut l’appeler avec au minimum le nombre de parametres définis lors de la déclaration de la fonction.

Lorsqu’on appelle une fonction avec des paramètres en moins, une erreur survient.

Si on l’appele avec plus de paramètres, il n’y aura aucune erreur.

Il est aussi possible d’appeler une fonction n’ayant aucun parametre définis et lui donner n parametres

	function maFonction(){	}
	maFonction(1,2,3);

Comment utiliser une fonction avec n parametres

Il existe des fonctions a notre disposition afin de gérer cette difficulté :

	/**
	* Fonction avec N param
	*/
	function infini()
	{
		//Récupére les paramétres
		$tableau_parametres	= func_get_args() ;
		print_r($tableau_parametres) ;
	}

	infini(1,56,2,5,6,9,52,3,6,9,8,7,5,2,5,9,2) ;

	/**
	* Fonction avec N param
	*/
	function infini()
	{
		//Récupére le paramétre 1
		echo func_get_arg(1) ;
	}

	infini(1,56,2,5,6,9,52,3,6,9,8,7,5,2,5,9,2) ;

	/**
	* Fonction avec N param
	*/
	function infini()
	{
		//Récupére le nombre de parametres
		echo func_num_args() ;
	}

	infini(1,56,2,5,6,9,52,3,6,9,8,7,5,2,5,9,2) ;

Paramètres par défaut

Il est possible lors de la definition de la fonction, de définir certains paramètres par défaut.

Ces parametres doivent etre le plus a droite possible.

Les paramètres par défauts possibles :

• $x = null
• $x = array()
• $x = ‘b’
• $x = 1.75 / 1 / true

Les paramètres par défaut impossibles :

• $x = maFonction()
• $x = 1+1
• $x = date(‘Y’)
• $x = new DC()

Si un paramètre à une valeur par défaut, il n’est pas obligatoire de spécifier ce paramètre.

	function maFonction($x=3){
		echo $x+10;
	}
	maFonction();

IMPORTANT : Exemple a noter :

	function maFonction($x,$x,$x,$x){
		echo $x;
	}
	maFonction(1,3,4,7); // affichera 7

Passage par référence

Un passage par référence permet de modifier une variable externe depuis une fonction.

	function maFonction(&$x){
		$x+=10;
	}
	$y=5;
	maFonction($y);
	echo $y; //affichera 15;
	//OU
	function maFonction($x){
		$x+=10;
	}
	$y=5;
	maFonction(&$y);
	echo $y; //affichera 15;

La fonction ‘shuffle’ par exemple est une fonction par référence.

Spécification de type

En PHP5, il est possible de spécifier le type du paramètre.

	function ( type param1[, ...]){ }

Le typage est facultatif. Ils permettent d’ajouter une rigueur au code.

Les types autorisés

• Tableaux
• Nom de classe
• Nom de l’interface

Exemple

	/**
	* Fonction typé
	* @param array $tab tableau contenant des chiffres
	*/
	function pourUnTableau(array $tab)
	{

	}
	pourUnTableau( array(5,2,3) ) ;
	/**
	* Fonction typé
	* @param object $classe classe quelquonque
	*/
	function pourUneClasse(stdClass $classe)
	{

	}
	pourUneClasse( new stdClass() ) ;

Si on ne respecte pas le typage, on obtient une erreur.

Les variables dans une fonction

Portée et durée de vie des variables d’une fonction

Une variable pour etre utilisée dans une fonction doit être déclarée dans cette derniere.

	$x	= 5 ; //Variable de portée GLOBAL
	function utilisationVariable()
	{
		echo $x ; //Variable de portée LOCALE
	}
	utilisationVariable() ; //Erreur E_NOTICE

Apres chaque execution, les variables sont détruites

Variables Statiques

Une variable statique se déclare via le mot clé ‘static’ suivi du nom de la variable.

La portée d’une variable statique est locale dans une fonction.

Sa durée de vie : jusqu’a la fin du programme.

Exemple:

	$x	= 5 ; //Variable de portée GLOBAL
	function utilisationVariableStatic()
	{
		static $x ; //Déclaration de la variable static de portée locale
		echo $x ;
		$x+=5 ;
	}
	utilisationVariableStatic() ; //NULL
	utilisationVariableStatic() ; //5
	utilisationVariableStatic() ; //10

Acces aux variables globales

Il existe deux méthodes pour acceder aux variables globales :

• mot clé GLOBAL
  
  On est dans l’obligation de mettre à On register_globals dans le php.ini
  
  ATTENTION : Pour des questions de securité, register_globals est à Off et dans PHP6, elle n’existera plus.
  

  	//global $nom_var_globale;
  	$x	= 5 ; //Variable de portée GLOBAL
  	function utilisationVariableGlobal()
  	{
  		global $x ; //Importe dans la porté locale la variable de la portée globale
  		echo $x ;
  	}
  	utilisationVariableGlobal() ;
  

• tableau super global $GLOBALS
  
  C’est un tableau, il peut etre utilisé partout.

  	//$GLOBALS['nom_variable_globale'];
  	$x	= 5 ; //Variable de protée GLOBAL
  	function utilisationVariableGlobalMotClef()
  	{
  		global $x ;
  		echo $x;
  		$x	+= 5 ;
  	}
  	function utilisationVariableGlobalSuperTableau()
  	{
  		echo $GLOBALS['x']	;
  	}
  	utilisationVariableGlobalMotClef() ; // 5
  	utilisationVariableGlobalSuperTableau(); //10
  

$GLOBALS est un tableau dont les valeurs sont assignées par références

Recursivité

Une fonction recursive est une fonction qui s’appelle elle même.

Exercice : Ecrire une fonction recursive permettant d’afficher un chiffre allant de 1 à 99

Probleme : Réaliser une fonction qui permet de parcourir un repertoire et d’afficher le nom du repertoire, et les fichiers.

Variables fonctions

Il existe en PHP des variables fonctions : à partir d’une variable, on peut appeler une fonction :

	callFonction();
	$var='callFonction';
	$var();