Les bases de la programmation PHP

Dr N. BAME
 Passer du HTML au PHP
• Il y a quatre jeux de balises qui servent à délimiter des
blocs de code PHP.
<?php et ?>
<? et ?>
<script language="php"> et </script>
<%php et %>

• Seules deux d'entre elles sont toujours actives :

<?php ... ?>
et <script language="php">...</script>

• Les autres peuvent être activées et désactivées depuis

le fichier de configuration php.ini.
 Passer du HTML au PHP
• Les balises courtes <? … ?> et les balises ASP <% …
%> peuvent être pratiques, mais elles ne sont pas
aussi portables que les versions longues.
• si vous envisagez d'inclure du PHP dans des
fichiers XML ou HTML, vous devrez utiliser la
forme <?php ..….?> pour vous conformer au XML.
Exemple
 Remarque
• La première méthode est généralement utilisée,
car elle permet une implémentation aisée de PHP
avec la génération actuelle de HTML.
 Le séparateur d'instructions
• Les instructions sont séparées par un point virgule
à chaque fin d'instruction, comme en langage C.
• La balise de fin (?>) implique la fin d'une
instruction, et donc ajoute implicitement un point
virgule.
• Les deux exemples suivants sont équivalents.
<?php echo "Ceci est un test";
?>

<?php echo "Ceci est un test" ?>

 Envoi des données au navigateur
• Il existe plusieurs fonctions pour envoyer des
données au navigateur, les plus courantes étant
echo() et print():

echo 'Hello, world ! ';

print "Ceci est un test";

• On peut employer des apostrophes ou des

guillemets pour encadrer une chaîne de caractère.
 L’échappement
• Une des complications de l’envoi de données à un
navigateur est l’affichage de guillemets ou
d’apostrophes.
• Ces deux exemples provoqueront une erreur:

• echo "Vous exécutez le fichier : "exemple.php" ";

• print 'Comme un script PHP doit être décodé par
un serveur, vous devez utiliser l'URL
http://localhost/exemple.php si vous disposez
d'un serveur local';
 L’échappement
• A cette difficulté, il y a deux solutions :
1. Utiliser des guillemets quand on veut afficher une
apostrophe et réciproquement:
echo 'Vous exécutez le fichier : "exemple.php" ';
print "Comme un script PHP …. utiliser l'URL …. si vous
disposez d'un serveur local";

2. Echapper le caractère litigieux en le faisant

précéder par un antislash (\):
echo "Vous exécutez le fichier : \"exemple.php\" ";
print 'Comme …. utiliser l\'URL …. d\'un serveur local';
 Remarques
• PHP est insensible à la casse en ce qui concerne les
noms de fonctions:
echo() = ECHO() = eCHo()
• On peut utiliser ces fonctions pour envoyer du
HTML au navigateur:

echo '<p>Hello, <span>world</span> !</p>';

• Echo() (mais pas print) permet d’envoyer plusieurs

informations découpées au navigateur en les
séparant par des virgules:
echo 'Hello, ', "world!";
 PHP, HTML et l’espace blanc
• Pour modifier la mise en page en accentuant
l’espacement des lignes de la page Web affichée, on
peut utiliser les balises <br /> (rupture de ligne) ou
<p></p> (marques de paragraphe).
• Pour modifier l’espacement du code HTML à l’aide
de PHP, on a le choix entre:

• Utiliser echo() ou print() entre plusieurs lignes;

• Utiliser le caractère alinéa (\n) placé entre une paire
de guillemets.
 Créer des espaces blancs
<?php
echo 'Cette instruction echo() se continue
sur deux lignes!';
echo "<br />Cette ligne devrait apparaître
isolée dans la page Web.\n\n";
echo 'C\'est gagné !';
?>
 Commentaires
• PHP supporte les commentaires comme en C, C++
et Shell Unix.
• Par exemple :
• <?php
echo "Ceci est un test"; // Ceci est un commentaire sur une ligne
comme en C
/* Ceci est un commentaire sur plusieurs lignes,
comme en C et C */
echo "Ceci est encore un test";
echo "Enfin, le test final"; # Ceci est un commentaire comme en Shell
Unix

• ?>
 Variables
• Les variables sont destinées à conserver
temporairement des valeurs.
• Le typage des variables est implicite en php.

• Il n’est donc pas nécessaire de déclarer leur type au

préalable ni même de les initialiser avant leur
utilisation.
 Variables
• Il y a huit types de variables dans le langage PHP :
• 4 de types scalaires (valeur unique):
– booléennes (TRUE ou FALSE), entières, flottantes (avec
une partie décimale), et chaînes de caractères (texte),
• Deux non scalaires (plusieurs valeurs): tableaux et
objets.
• Plus les ressources (rencontrées lorsqu'on travaille
avec une base de données) et NULL (qui est une
variable spéciale dépourvue de valeur).
 Les variables: règles syntaxiques

• Tout nom de variable doit commencer par un caractère

($). Exemple: $nom.
• Le nom peut contenir une combinaison de caractères,
chiffres et du caractère blanc souligné (_). Exemple:
$le_prix2.
• Le premier caractère qui suit le $ initial ne doit pas être
un chiffre. Il doit être une lettre ou un blanc souligné.
• Les noms de variables sont sensibles à la casse. $nom
et $Nom sont deux variables entièrement différentes.
• On affecte des valeurs aux variables à l'aide du signe
égale (=).
 Exemples
• Tous les noms de variables sont précédés d’un $
$my_var = 5;

• Les variables n'ont pas besoin d'être déclarées.

$my_var = 123;

• Il n'est pas nécessaire de typer les variables, c'est-à-

dire de leur définir un type.
– Il suffit de leur assigner une valeur pour en définir le type :
$a=10;
$ch=‘toto’;
 Types de données en PHP
• Types de base
 nombres entiers,
 nombres à virgule flottante,
 chaînes de caractères,
 booléen
• tableaux
• objets
 Types de données
• Type entier :
– $var1 = 32 ; // est un entier en base 10,
– $var2 = -23 ; // est un entier négatif,

• Type flottant ou double :

– $var3 = 4.5 ; // est un nombre à virgule flottante,

• chaînes de caractères: ensemble de caractères entre guillemets

simples ou doubles
– $ch1 = ‘Mamadou’ ; // est une chaîne de caractères
– $ch2 = "Ndiaye" ; // est aussi une chaîne de
//caractères

• Booléen
– $encours = true;
 Type d’une variable (1)
• PHP détermine automatiquement le type d’une variable en
fonction de la valeur.

• Il existe néanmoins un certain nombre de types de données :

 Entier (integer): pour les nombres entiers,
 Float (ou Double) (float): nombres réels,
 Chaînes (string): pour les chaînes de caractères,
 Booléen (boolean): pour des valeurs de type vrai ou faux,
 Tableau (array): pour stocker des données du même type,
 Objet (object): pour stocker des instances de classes,

• Deux types particuliers sont également proposés :

 NULL: pour des valeurs de type non définies,
 ressource: retournées fréquemment par des fonctions accédant à
des ressources externes (fichiers, BD, …)..
 Type d’une variable (2)
• PHP dispose de fonctions permettant de connaître le type
courant d’une variable.
• Ces fonctions retournent true ou false

• is_array(),
• is_double(), is_float(), is_real() - c'est la même fonction,
• is_long(), is_int(), is_integer()- c'est la même fonction,
• is_string(),
• is_object(),
• is_ressource(),
• is_null(),
• is_scalar() - si la variable est scalaire, c'est à dire si c'est un
entier, une chaîne, ou un double.
• is_numeric() - si la variable est un nombre ou une chaîne
numérique,
 Type d’une variable (3)
• PHP dispose aussi de fonctions permettant de
connaître l'état de variables :
– isset () : retourne true ou false selon que la variable
passée en paramètre existe ou pas,
– unset () : supprime la variable passée en paramètre,
– empty() : retourne un booléen selon que la variable est
non vide ou non nulle.
 Conversion de type
• Il existe des fonctions qui aident à la réalisation du
transtypage de variables :
– int intval(variable),
– float floatval(variable),
– string strval(variable).
• On peut également utiliser la fonction settype() pour changer
le type d’une variable
settype($variable, ‘newType’);

• On peut également faire le transtypage d’une variable avec le

mécanisme de «cast» : préfixer la variable par le nouveau
type entre parenthèses.
– (newType)$var;
• Exemple
$ch=‘20’;
(int)$ch;
 Opérateurs arithmétiques

• Affectation : = • Division : /
– $var1 = 10 ; • $var5= $var1/$var2 ;

– $var2 = 2 ;
• Multiplication :*
• $var6= $var1*$var2 ;
• Addition : +
– $var3= $var1 + $var2 ;
• Modulo : %
• $var7= $var1 %$var2 ;
• Soustraction : -
– $var4= $var1-$var2 ;
 Affectation
• =
• +=
$var += 1; //ajoute à la valeur existante
• -=
$x -= 2; //soustrait à la valeur existante
• *=
$x *= 3; //multiplie la valeur existante
• /=
$x /= 4; //divise la valeur existante
 Comparaison
• == : égal à
X==Y
• != : différent de
X!=Y
• <> :différent de
X<>Y
• > : Supérieur à
• >= : Supérieur ou égal à
• < : Inférieur à
• <= : inférieur ou égal à
 Incrémentation et diminution

Incrémentation ++ Diminution --
$x = 5; $x = 5;
echo ++$x; //incrémente echo --$x; //réduit puis
//puis affiche 6 affiche 4
echo $x; //affiche 6 echo $x; //affiche 4
$x = 5; $x = 5;
echo $x++; //affiche 5 echo $x--; //affiche 5
//puis incrémente //puis réduit
echo $x; //affiche 6 echo $x; //affiche 4
 Condition et comparaison logique (1)
• Condition (?)
L'opérateur ternaire "?" est une alternative :
• "est-ce vrai ? valeur si oui : valeur sinon";

• Les opérateurs de comparaison logique

permettent de vérifier plusieurs conditions à la fois dans
un même test.
On peut écrire les opérateurs "and" et "or" en
minuscules ou en majuscules.
&& est identique à AND
|| est identique à OR
Condition et comparaison logique (2)
 Chaines de caractères
• Affichage
– echo
• echo $var3;
• echo " Mamadou Ndiaye"
– print et printf

• Concaténation
– Avec guillemets doubles
• $ch= "Je suis $var3 "
– Avec guillemets simples
• $ch= ‘Je suis’.$var3
– . = : concatène à la suite de la chaîne existante
• $ch = ‘je suis’;
• echo $ch.=’Mamadou Ndiaye’ ; // affiche je suis Mamadou Ndiaye
 Portée d’une variable
• La portée d’une variable dépend du contexte dans lequel elle
est définie ;

• La plupart des variables ont une portée qui s’étend sur

l’intégralité du script PHP. Dans ce cas, elles sont globales ;

• Cependant, les variables sont locales au sein d’une fonction ;

$toto = 1; // portée globale

function affiche () {
$titi=5;
echo $titi; // portée locale
}
 Portée d’une variable
• On distinguera les variables à portée :

• Globale : lorsqu'une variable est déclarée à l'extérieur de

toute fonction ou de tout bloc d'instruction, elle est
accessible (visible) de partout dans ce code

• Locale : lorsque une variable est déclarée à l'intérieur d'un

bloc d'instructions ou d’une fonction, sa portée est alors
locale à ce bloc ou cette fonction
 Portée d’une variable
• Deux façons existent pour accéder à une variable
globale au sein d’un bloc :
déclarer la variable comme global au sein du bloc,
utiliser le tableau associatif $GLOBALS avec comme clé le
nom de la variable globale.
• Exemple
$toto = 1; // portée globale
$titi = 2; // portée globale
function affiche () {
global $toto; // portée globale
echo "$toto et $GLOBALS[’titi’]";}
affiche();
– Cet exemple affichera 1 et 2.
 Variables préfinies
• PHP dispose d’un grand nombre de variables
prédéfinies,
– qui contiennent des informations à la fois sur le serveur et
sur toutes les données qui peuvent transiter entre le poste
client et le serveur,
• comme les valeurs saisies dans un formulaire, les cookies ou les
sessions
• Elles sont accessibles pendant toute l’exécution du
script.

• C es variables se présentent sous la forme de tableaux,

accessibles en tout point de n’importe quel script. On
appelle ces tableaux superglobaux.
 Variables préfinies

Variable Description
$GLOBALS Nom et valeur de toutes les variables globales
du script
$_COOKIE Nom et la valeur des cookies enregistrés sur le
poste client
$_FILES Nom des fichiers téléchargés à partir du poste
client.
$_GET N om et la valeur des données issues d’un
formulaire envoyé par la méthode GET.
$_POST Nom et la valeur des données issues d’un
formulaire envoyé par la méthode POST.
$_SESSION Contient l’ensemble des noms des variables de
session et leurs valeurs.
 Les constantes
• Une constante est une variable dont la valeur est
inchangeable lors de l'exécution d'un programme

• Les constantes sont définies grâce à la fonction define(), dont

la syntaxe est la suivante :

– define("CONSTANT_NAME", "CONSTANTE_VALUE")
– echo CONSTANT_NAME; // affiche CONSTANTE_VALUE

• Le nom d'une constante définie, à l'aide de la fonction

define(), ne doit pas commencer par le caractère $ (de cette
façon aucune affectation n'est possible).

• Contrairement aux variables, les identificateurs de constantes

(et aussi ceux de fonction) ne sont pas sensibles à la casse.
 Les constantes
• Les constantes ne peuvent pas être affichées à
l’intérieur de chaînes de caractères placées
entre apostrophes ou entre guillemets car
l’absence du caractère dollar initial entraînerait
leur affichage sous forme de texte.
• On a donc utilisé l’opérateur de concaténation
à l’intérieur de cette instruction
 Les constantes
• L’affichage des constantes peut se faire de deux
façons :
echo 'Hello, ' . NOM;
Ou
echo 'Hello, ' . NOM;
• Mais on ne peut pas écrire :
echo 'Hello, NOM'';
– (PHP afficherait tout simplement : Hello, NOM et non
pas la valeur de la constante NOM).
 Constantes prédéfinies
• PHP dispose de constantes prédéfinies comme:
PHP_VERSION
PHP_OS
NULL
TRUE
FALSE
 Exemples
<?php
# constantes.php
// Définir la date
define ('AUJOURD_HUI', '11 janvier 2016');
// Afficher le message
echo ‘Aujourd\’hui nous sommes le ‘.AUJOURD_HUI.
'<br />La version de PHP de ce serveur est la
<strong>‘.PHP_VERSION.‘</strong> et son système
d\’exploitation est <strong>‘.PHP_OS.‘</strong>.<br
/><br />';
?>
 Les structures de contrôle
• Dans tout langage de programmation, y compris en
PHP, il existe deux types de structures de contrôle :
• Instructions conditionnelles. Ces instructions
exécutent du code si une condition est soit vraie,
soit fausse.
• Boucles conditionnelles. Ces boucles exécutent un
jeu d’instructions une ou plusieurs fois jusqu’à ce
qu’une condition soit évaluée soit comme vraie, soit
comme fausse.
 Les instructions conditionnelles
• Le principe d’une instruction conditionnelle est le
suivant : une expression conditionnelle est évaluée
et, si la condition est vraie ou fausse, du code est
exécuté.
• En PHP, les instructions conditionnelles les plus
courantes sont :
if … else … elseif
switch … case
• Permettent de faire des traitements dépendants de
certaines données déterminées par des conditions
• Personnaliser la page générée en fonction
d’informations concernant l’utilisateur
 La structure de base if … else
• La structure if
– Permet l’exécution conditionnelle d’une partie du code
– Mêmes fonctionnalités qu’en C
Syntaxe
if (condition)
{ Traitement // à exécuter si condition vaut true;
}
• Souvent on souhaite exécuter une instruction si une condition est
remplie, et une autre instruction si cette condition n’est pas remplie.
• Dans ce cas, on utilise else
Syntaxe
if (condition){ Traitement 1 // à exécuter si condition vaut true;
}else
{ Traitement 2 // à exécuter si condition vaut false;
}
 La structure else if
• elseif permet, comme l’expression else, d’exécuter une instruction après un if
dans le cas où ce dernier est évalué comme faux ;
• A la différence de l’expression else, il n’exécutera les instructions que si
l’expression condionnelle elseif est évaluée comme vraie ;
• Syntaxe:
if (condition1) {
Traitement1; // instructions à exécuter si la condition1 est vraie...
} else if (condition2) {
Traitement2; //instructions à exécuter si la condition2 est vraie...
} else if (condition3) {
Traitement3; // instructions à exécuter si la condition3 est vraie......
} else {
TraitementN ;// instructions à exécuter si aucune des conditions n’est vraie...
}
• Exemple
– Résolution d’une équation du 2nd degré dans R
 Syntaxe de if proposée par PHP
if (condition1) :
Traitement1; // instructions à exécuter si la condition1 est vraie...
elseif (condition2) :
Traitement2; // instructions à exécuter si la condition2 est vraie...
elseif (condition3) :
Traitement3; // instructions à exécuter si la condition3 est vraie...
else :
TraitementN; // instructions à exécuter si aucune des conditions
n’est vraie...
endif;
 Exemple
<?php
# traite_formu.php
……………………..
// Instructions conditionnelles
if ($sexe == "M") :
echo "<p><strong>Bonjour Monsieur</strong></p>";

elseif ($sexe == "F") :

echo "<p><strong>Bonjour Madame</strong></p>";
else :
echo "<p><strong>Vous avez oublié d'indiquer votre
sexe</strong></p>";
Endif;
?>
 La structure switch
• Il existe en PHP une autre instruction conditionnelle
appelée switch que l’on peut utiliser à la place d’une
cascade de if – elseif – else.
• Syntaxe :
switch ($variable)
{
case "valeur_1" :
// Faire ce traitement
Break;
case "valeur_2" :
// Faire cet autre traitement
Break;
default :
// Troisième traitement
}
 Fonctionnement
• La valeur de $variable est comparée
successivement à toutes les valeurs de case.
• Lorsqu’on trouve une égalité, le code qui suit est
exécuté jusques et y compris le break, qui a pour
effet de faire sortir du switch.
• Si aucune égalité n’est trouvée, c’est la clause
default qui est exécutée.
– A sa suite, aucun break n’est évidemment nécessaire.
 Exemples
switch ($sexe)
{
case "M" :
echo "<p><strong>Bonjour Monsieur</strong></p>";
break;
case "F" :
echo "<p><strong>Bonjour Madame</strong></p>";
break;
default :
echo "<p><strong>Vous avez oublié d'indiquer votre
sexe</strong></p>";
}
 Exemple
• Alternative à : if … elseif … else
<?php
$mois= 1;
switch ($mois) // on indique sur quelle variable (ou expression) on travaille
{
case 1: // dans le cas où $mois vaut 1
echo "C’est Janvier !!!"; break;
case 2: // dans le cas où $mois vaut 2
echo "C’est Fevrier !!!"; break;
case 3: // dans le cas où $mois vaut 3
echo "C’est Mars!!!"; break;
---
case 11:
echo "C’est Novembre !!!"; break;
case 12:
echo "C’est Novembre !!!"; break;
default:
echo " Ce numero de mois n’existe pas";
}
?>
 Les boucles
• permettent de répéter des instructions plusieurs
fois

• Il doit avoir toujours une condition d’arrêt de

l’itération qui est vérifier à chaque début du bloc
 La boucle while
• Syntaxe:
while (condition)
{
Traitement ;
}
• Exemple
<?php
$n=1; $x=6;
while ($n<11)
{
echo "$x X $n = $x*$n";
$n++;
}
?>
 Syntaxe de while proposée par PHP
while (condition) :
Traitement; //instructions à exécuter tant
//que la condition est vraie...
endwhile;
 La boucle do … while
• Même fonctionnement que while
– Sauf que la première itération est toujours exécutée
– Pas d’évaluation de la condition pour la première
exécution
• Syntaxe
do
{
Traitement ;
} while (condition);
 La boucle for
• Syntaxe
for (expression1; condition; expression2) {
Traitement; //instructions à exécuter tant que la condition est vraie...
}
• expression1 est exécutée au début de la boucle
• condition est vérifier avant chaque itération
• expression2 est évaluée à la fin de chaque itération
 Syntaxe de for proposée par PHP

• Syntaxe simplifié
for (expression1; condition; expression2) :
Traitement //instructions à exécuter tant que la condition est vraie
endfor;
 La boucle foreach
• Très pratique pour parcourir un tableau ou une
liste d’objets
• Syntaxe
foreach(tableau as $index =>$valeur)
{
echo "$index $valeur ";
}
Exemples
 Les tableaux
• Les tableaux stockent des données sous forme de liste.

• Les données du tableau peuvent être accédées grâce à

une clé (ou index, un entier ou une chaîne de
caractères).

• Les éléments d’un tableau en PHP peuvent être de

types différents.

• La création d’un tableau se fait avec :

– La fonction array()
– L’affectation direct des valeurs au tableau
 Tableaux numérotés
• Chaque case est identifié par son index qui correspond à la
clé de l’élément
• L’index correspond à la position de l’élément
– Le premier élément a pour index 0
• Création
<?php
$prenoms = array (‘Mamadou', ‘Fatou', ‘Alpha', ‘Ibrahima',‘Momar');
$noms[]=‘Ndiaye’;
$noms[]=‘Faye’;
$noms[]=‘Diop’;
$noms[]=‘Diallo’;
$noms[]=‘Samba’;
?>
• Accès à un élément
Nom_tableau[index];
 Tableaux associatifs
• Dans ce cas les index correspondent à des noms
différents
• Création
<?php
$etudiant = array (
'prenom' => ‘Mamadou',
'nom' => 'Ndiaye',
'adresse' => '3 Rue du Paradis',
'Telephone' => '+221708456701');
?>
• Affichage
<?php
echo $etudiant ['adresse'];
?>
 Parcourir un tableau
for($numero=0; $numero<taille_tableau; $numero ++)
{Traitement;}
foreach($tableau as $element) {Traitement;}

foreach($tableau as $cle => $element)

print_r($element);
foreach($noms as $cle => $element)
echo "$cle => $element <br/>";

while (list ($key, $val) = each ($noms))

{echo "$key => $val <br/>";}
 Recherche dans un tableau
• array_key_exists : vérifier si une clé existe dans l'array
array_key_exists('cle', $array);
array_key_exists('nom', $etudiant)

• in_array : vérifier si une valeur existe dans l'array

in_array('element', $array)
in_array('Mamadou', $etudiant)

• array_search : récupérer la clé d'une valeur dans

l'array ou false
$attribut = array_search(‘element', $array);
$attribut = array_search(‘Ndiaye', $etudiant);
 Fonctions utiles de tableaux
• reset($array) : Remet le pointeur interne de tableau au
début.
• pos($array) : Retourne la valeur de l'élément courant d'un
tableau.
• key($array) : Retourne l'indice de l'élément courant d'un
tableau.
• current($array) : Retourne la valeur de l'élément courant
d'un tableau.
• next($array) : Avance le pointeur interne d'un tableau.
• prev($array) : Recule le pointeur courant de tableau.
• end($array) : Positionne le pointeur de tableau en fin de
tableau.
• each($array) : Retourne la paire clé/valeur courante et
avance le pointeur de tableau.
 Fonctions utiles de tableaux
• array_merge ($tab1, $tab2... ) Ajoute deux tableaux
• count ($tab) Compte les éléments d'un tableau.
• array_keys($tab) Retourne toutes les clés d'un tableau
• array_values($tab) Retourne les valeurs d'un tableau
• array_key_exists($key, $tab) Regarde si une clef existe.
• array_search($val,$tab) Recherche la clé associée à
une valeur.
• array_flip($tab) : Retourne un tableau : clefs <> valeurs
 Fonctions utiles de tableaux
• sort ($array) Trie un tableau par valeurs croissantes.
• rsort ($array) Trie un tableau par valeurs
décroissantes.
• ksort($array) Trie un tableau par valeurs de clefs
croissantes.
• krsort($array) Trie un tableau par valeurs de clefs
décroissantes.
• shuffle ($array) Mélange les éléments d'un tableau.
 Les fonctions
• On distingue 2 types de fonctions :
 les fonctions intégrées ou built-in qui sont inclues par défaut avec
les distributions de PHP comme print, echo et
 les fonctions définies par le programmeur.

• Les fonctions ont plusieurs buts :

 Éclaircir le code en regroupant dans une même fonction certaines
fonctionnalités d'un programme qui se répètent.

 Pouvoir créer des fonctions génériques qui pourront être utilisées

dans d'autre programme
 ce qui évite de répéter pour chaque projet le même code

 Possibilité d'évolution du code plus facile (modification du

contenu d'une fonction)
 Syntaxe de déclaration
Une fonction se déclare et s’utilise de la manière
suivante :
<?php
//déclaration
function ma_fonction($arg_1, $arg_2, ..., $arg_n)
{
// code de la fonction
return($une_variable); // facultatif
}
$retour = ma_fonction(2, 5); //appel
?>
 Exemples
// fonction sans paramètre qui affiche " Bonjour ! "
// pas de valeur de retour
function afficher_bonjour()
{
echo "Bonjour !<BR>";
}
// utilisation de la fonction afficher_bonjour
afficher_bonjour();
 Exemples
// fonction avec 2 paramètres qui retourne le
//produit des deux paramètres

function produit($valeur1,$valeur2)
{
return $valeur1 * $valeur2;
}
 Exemples
// utilisations de la fonction produit
// - dans une affectation
$résultat = produit(2,4);
echo "$résultat<BR>";
// - dans une comparaison
if (produit(10,12) > 100) {
echo "Le résultat est supérieur à 100.<BR>";
}
// - dans une affectation et une comparaison (lisibilité ?)
if (($résultat = produit(10,12)) > 100)
{
echo "$résultat est supérieur à 100.<BR>";
}
 Remarques
• Il est possible d'utiliser une fonction avant de la
définir.
• Exemple
<?php
// utilisation de la fonction produit
echo produit(5,5);
// définition de la fonction produit
function produit($valeur1,$valeur2) {
return $valeur1 * $valeur2;
}
?>
• Il n'y a donc aucun problème pour définir des
fonctions qui s'appellent entre elles.
 Passage des arguments d'une fonction
• Passage par valeurs : la fonction ne modifie pas ses
arguments.
 c'est a dire que s'ils ont une valeur à l'extérieur de la fonction,
seule la valeur est transmise à la fonction,
 si la variable subit des modifications à l'intérieur de la fonction,
ces modifications ne seront pas perçues dans le programme
principal.

• Passage par référence : permet à la fonction de pouvoir

modifier la valeur de l’argument
 Se fait avec le signe & avant la variable. Dans ce cas, l'adresse
mémoire de la variable dans le programme est passée à la
fonction et toute modification de cette variable dans la fonction
aura des répercutions à l'extérieur du programme.
$n=4;
function doubler(&$n)
{ $n *= 2;
}
 Nombre de paramètres variables
• Passer un tableau de variables (le plus simple)
• Utiliser les fonctions suivantes.
func_num_args : nombre d’arguments de la fonction
courante
func_get_arg : renvoie l’argument de la position spécifiée
func_get_args : renvoie un tableau contenant tous les
arguments
• Syntaxe
entier func_num_args()
tableau func_get_args()
mixte func_get_arg(entier numéro)
numéro Numéro du paramètre demandé (0 = premier paramètre).
 Nombre de paramètres dynamique
• À l'aide de ces fonctions natives, il est alors très
simple d'écrire une fonction qui accepte un nombre
variable de paramètres.
• Les principes sont les suivants :
1. déclarer la fonction sans paramètre ;
2. récupérer, dans le corps de la fonction, les paramètres
avec les fonctions func_get_args ou func_get_arg et les
utiliser (typiquement dans une boucle).
 Nombre de paramètres variables
Exemples
<?php
function nbArgs()
{
$numargs = func_num_args();
echo "Nombre d'arguments: $numargs\n";
}

// Appel
nbArgs(1, 2, 3); // affiche 'Nombre d'arguments: 3'
?>
 Nombre de paramètres variables
// fonction qui effectue le produit de tous les paramètres
function produit() {
if (func_num_args() == 0) { // pas de paramètres => résultat= 0
$résultat = 0;
} else { // récupérer les paramètres dans un tableau
$paramètres = func_get_args();
$résultat = 1;
// faire une boucle sur le tableau des paramètres pour
multiplier le résultat par le paramètre
foreach($paramètres as $paramètre)
{$résultat *= $paramètre;}
}
// retourner le résultat
return $résultat;
}
 Nombre de paramètres variables
// appels
echo produit()."<BR>";
echo produit(1)."<BR>";
echo produit(1,2)."<BR>";
echo produit(1,2,3)."<BR>";
echo produit(1,2,3,4)."<BR>";

Résultat
0
1
2
6
24
 Inclure des portions de pages
• Une des fonctionnalités les plus simples et les plus
utiles de PHP est l'inclusion de pages
• On peut inclure une page ou un bout de page à
l'intérieur d'une autre.
• Eviter de recopier le même code HTML plusieurs
fois
– l'en-tête ;
– le menu ;
– le pied de page.
 Inclure des portions de pages
• Fonctionnement
• Les fonctions include, include_once, require et
require_once permettent d'inclure un fichier dans
un script PHP.
• Syntaxe
entier include(fichier)
entier include_once(fichier)
require (fichier)
require_once(fichier)
– fichier Nom du fichier à inclure (peut être indiqué avec
un chemin absolu ou relatif).
 Inclure des portions de pages
• Les fonctions include et include_once retournent 1
en cas de succès et FALSE en cas d'erreur.
• Les fonctions require et require_once n'ont pas de
code de retour.

• En cas d'erreur, les fonctions include et

include_once génèrent une simple erreur de niveau
E_WARNING qui n'interrompt pas l'exécution du
script.
• Ce n'est pas le cas des fonctions require et
require_once qui provoquent alors une erreur
fatale interrompant l'exécution du script.
 Inclure des portions de pages
• Le fichier inclus peut contenir du code HTML, du code PHP ou
les deux.
• S'il offre du code PHP, ce code doit être écrit entre les balises
PHP habituelles.
• Le code HTML, présent dans le fichier inclus, est intégré tel
quel dans la page envoyée au navigateur, comme s'il était
dans le script appelant.
• Le code PHP, présent dans le fichier inclus, est exécuté là
encore, comme s'il était dans le script appelant.
• Lors de l'inclusion de code PHP, les variables et constantes,
définies dans le fichier inclus sont utilisables dans le script
appelant et réciproquement.
• Tout se passe comme s'il n'y avait qu'un seul script après
l'inclusion, et donc, une portée égale à ce script pour les
variables et constantes.
 Inclure des portions de pages
• Il est possible d'inclure plusieurs fichiers dans un script,
ou d'imbriquer les inclusions (inclure un fichier qui lui
même inclut un fichier dans un autre).

• Avec les fonctions include et require, le processus

d'inclusion est répété plusieurs fois si le même fichier
est inclus plusieurs fois.

• Dans certains cas, cette situation peut être indésirable

et involontaire, notamment lorsqu'un fichier est inclus
une première fois directement dans un script et une
deuxième fois indirectement par l'inclusion d'un autre
fichier.
 Fichier inclus commun.inc
<!-- Démarrage du fichier d'inclusion en mode HTML
(ouverture
---- d'une balise <p> qui est fermée à la fin du fichier --
<p> Début du fichier commun.inc<BR>
<?php
// déclaration d'une variable $x dans le script principal
$y = 2;
// affichage de la variable $x (définie dans le script
// appelant)
echo "Valeur de \$x dans le fichier inclus : $x<BR>";
// affichage de la variable $y
echo "Valeur de \$y dans le fichier inclus : $y<BR>";
?>
Fin du fichier commun.inc </p>
 Exemple ‐ Script principal
<?php
// déclaration d'une variable $x dans le script principal
$x = 1;
// inclusion d'un fichier
include("commun.inc");
// affichage de la variable $x
echo "Valeur de \$x dans le script principal : $x<BR>";
// affichage de la variable $y (définie dans le fichier
// inclus)
echo "Valeur de \$y dans le script principal : $y<BR>";
?>
Résultat de l'exécution du script principal
Début du fichier commun.inc
Valeur de $x dans le fichier inclus : 1
Valeur de $y dans le fichier inclus : 2
Fin du fichier commun.inc
Valeur de $x dans le script principal : 1
Valeur de $y dans le script principal : 2
 Exemple ‐ Script principal avec deux
inclusions du fichier commun.inc
<?php
include("commun.inc");
$x = 1;
echo "Valeur de \$x dans le script principal : $x<BR>";
echo "Valeur de \$y dans le script principal : $y<BR>";
include("commun.inc");
?>
 Résultat de l'exécution du script principal
• (si les erreurs de niveau E_NOTICE ne sont pas affichées)
Début du fichier commun.inc
Valeur de $x dans le fichier inclus :
Valeur de $y dans le fichier inclus : 2
Fin du fichier commun.inc
Valeur de $x dans le script principal : 1
Valeur de $y dans le script principal : 2
Début du fichier commun.inc
Valeur de $x dans le fichier inclus : 1
Valeur de $y dans le fichier inclus : 2
Fin du fichier commun.inc
• Sur cet exemple, lors de la première inclusion, la variable $x
n'a pas encore été définie dans le script principal et donne
donc une valeur vide lors de l'affichage.
 Script principal avec deux inclusions
include_once du fichier commun.inc
<?php
include_once("commun.inc");
$x = 1;
echo "Valeur de \$x dans le script principal : $x<BR>";
echo "Valeur de \$y dans le script principal : $y<BR>";
include_once("commun.inc");
?>
 Résultat de l'exécution du script principal
• (si les erreurs de niveau E_NOTICE ne sont pas
affichées)
Début du fichier commun.inc
Valeur de $x dans le fichier inclus :
Valeur de $y dans le fichier inclus : 2
Fin du fichier commun.inc
Valeur de $x dans le script principal : 1
Valeur de $y dans le script principal : 2
• La deuxième inclusion n'est pas effectuée car le fichier
a déjà été inclus et l'inclusion est demandée avec la
fonction include_once.
• Dans le fichier php.ini, la directive include_path permet
de définir des chemins de recherche pour l'inclusion
des fichiers.
 Utilisation
La technique d'inclusion est pratique pour deux grands types
d'utilisation :
• Inclure des définitions statiques : constantes, définitions de
fonctions.
– Dans ce cas, il faut plutôt utiliser les fonctions include_once ou
require_once afin d'éviter une éventuelle double inclusion (qui
provoquerait une erreur dans la définition des fonctions).
• Inclure du code PHP ou HTML dynamique qui s'exécute
effectivement au moment de l'inclusion :
– section HTML commune à plusieurs pages (en‐tête, pied de page)
ou code commun à plusieurs pages (bien que dans cette
hypothèse, la définition d'une fonction soit plus pertinente).
– Dans ce cas, il faut plutôt utiliser les fonctions include ou require
afin de garantir que l'inclusion se produit à chaque appel.
 Exemple 1
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8"/>
<link rel="stylesheet" href="style.css" />
</head>
<body>
<div id="bloc_page">
<?php include("entete.php"); ?>
<?php include("menu.php"); ?>
<div id="contenu">
---
</div>
<?php include("pied.php"); ?>
</div>
</body>
</html>
 Exemple 2
• Fichier de définition de constantes (constantes.inc) :
<?php
// définition des constantes
// par exemple, le nom du site
DEFINE("NOM_SITE","monSite.com");
?>
• Fichier contenant le début de chaque page (début.inc) :
<?php
// inclusion du fichier des contantes
include_once("constantes.inc");
?>
<HTML>
<HEAD><TITLE><?php echo NOM_SITE; ?></TITLE></HEAD>
<BODY>
 Exemple 2
• Fichier contenant la fin de chaque page (fin.inc) :
</BODY>
</HTML>
• - Script d'une page :
<?php
// inclusion du début de la page
include("début.inc");
?>
Contenu de la page ...
<?php
// inclusion de la fin de la page
include("fin.inc");
?>
 BONUS !!!
• nl2br ()
• La fonction stripslashes()permet de supprimer le caractère
d’échappement \ qui est automatiquement ajouté dans les
chaînes saisies. Si on ne l’utilise pas on obtient dans
l’exemple suivant l’affichage « l\'Odéon » au lieu de «
l'Odéon » .
• La balise HTML <pre> </pre> permet d'afficher un texte
exactement comme elle est en affichant tous les espaces,
...
<?php
$texte ="Une voiture";
?>
<pre> <?php echo $texte; ?> </pre>

Ce code va afficher Une voiture