---------------
Structures de
Contrôle
---------------
Les instructions conditionnelles
• L'instruction if
if (condition réalisée) { liste d'instructions }
• L'instruction if ... Else
if (condition réalisée) {liste d'instructions}
else { autre série d'instructions }
• L'instruction if ... elseif ... else
if (condition réalisée) {liste d'instructions}
elseif (autre condition ) {autre série d'instructions }
else { série d'instructions }
• Opérateur ternaire
(condition) ? instruction si vrai : instruction si faux
Les instructions conditionnelles
<?php
if ($a > $b)
echo "a est plus grand que b";
if ($c > $d)
echo "c est plus grand que d";
else
echo "d est plus grand que c";
?>
Les instructions conditionnelles
• L'instruction switch :
switch (Variable) {
case Valeur1: Liste d'instructions; break;
case Valeur2: Liste d'instructions; break;
case ValeurN: Liste d'instructions; break;
default: Liste d'instructions; break;
}
Les instructions conditionnelles
• La boucle for
for ($i=1; $i<6; $i++) { echo "$i<br>"; }
• La boucle while
while(condition) {bloc d’instructions ;}
while (condition) :Instruction1 ;Instruction2 ;
…. endwhile ;
• La boucle do…while
do {bloc d’instructions ;}while(condition);
Les instructions conditionnelles
<?php
/* exemple 1 */
$i = 1;
while ($i <= 10) {
echo $i++; /* valeur affichée est $i avant
incrémentation (post-increment) */
}
/* exemple 2 */
$i = 1;
while ($i <= 10):
echo $i;
$i++;
endwhile;
?>
Les instructions conditionnelles
• La boucle for
for ($i=1; $i<6; $i++) { echo "$i<br>"; }
• La boucle while
while(condition) {bloc d’instructions ;}
while (condition) :Instruction1 ;Instruction2 ;
…. endwhile ;
• La boucle do…while
do {bloc d’instructions ;}while(condition);
• La boucle foreach
Foreach ($tableau as $valeur) {
instructions utilisant $valeur; }
Les instructions conditionnelles
<?php
$arr = array(1, 2, 3, 4);
foreach ($arr as &$value) {
$value = $value * 2;
}
// $arr vaut maintenant array(2, 4, 6, 8)
unset($value); // Détruit la référence sur le dernier
// élément
?>
Les instructions conditionnelles
<?php
$fruit = "pomme";;
switch ($fruit) {
case "pomme" : echo "C'est une pomme."; break;
case "banane" : echo "C'est une banane."; break;
case "orange" : echo "C'est une orange."; break;
default : echo "Fruit inconnu."; }
}
$result = match ($fruit) {
"pomme" => "C'est une pomme.",
"banane" => "C'est une banane.",
"orange" => "C'est une orange.",
default => "Fruit inconnu.",
};
echo $result;
?>
goto
• L'opérateur goto peut être utilisé pour continuer l'exécution du
script à un autre point du programme.
• La cible est spécifiée par un label, suivi de deux-points, et
l'instruction goto est ensuite suivie de ce label.
• L'étiquette cible doit être dans le même contexte et fichier.
<?php
goto a;
echo 'salut’;
a:
echo 'tout le monde';
?>
continue
• L'instruction continue est utilisée dans une boucle afin d'éluder
les instructions de l'itération courante et de continuer
l'exécution à la condition de l'évaluation et donc, de
commencer la prochaine itération.
• Admet un paramètre numérique pour le nombre d’itérations à
ignorer.
<?php
for ($i = 0; $i < 5; ++$i) {
if ($i == 2)
continue ;
print "$i\n";
}
?>
break
• L'instruction break permet de sortir d'une structure for, foreach,
while, do-while ou switch.
• break accepte un argument numérique optionnel qui vous
indiquera combien de structures emboîtées doivent être
interrompues.
<?php
for ($i = 0; $i < 5; ++$i) {
if ($i == 2)
break;
print "$i\n";
}
?>
---------------
Fonctions
---------------
Fonctions
• Une fonction peut être définie en utilisant la syntaxe suivante :
Function nom_fonction($arg1, $arg2, …$argn){
// déclaration des variables ;
// bloc d’instructions ;
//fin du corps de la fonction
return $resultat ; }
Fonctions
• Une fonction peut être définie en utilisant la syntaxe suivante :
Function nom_fonction($arg1, $arg2, …$argn){
// déclaration des variables ;
// bloc d’instructions ;
//fin du corps de la fonction
return $resultat ; }
• func_num_args() : fournit le nombre d’arguments qui ont été
passés lors de l’appel de la fonction.
• func_get_arg($i) : retourne la valeur de la variable située à la
position $i dans la liste des arguments passés en paramètres, à
partir de l’indice 0.
Fonctions
• Une fonction avec un nombre inconnu de paramètres :
<?php
function produit() {
$nbarg = func_num_args() ;
$prod=1;
// la fonction produit a ici $nbarg arguments
for ($i=0 ; $i <$nbarg ; $i++) {
$prod *= func_get_arg($i);
}
return $prod;
}
echo "le produit est: ", produit(10, 5, 9), "<br />" ;
?>
Fonctions
• Passage des paramètres d’une fonction par référence :
<?php
function dire_texte($qui, &$texte){
$texte = "Bienvenue $qui";
}
$chaine = "Bonjour ";
echo $chaine;
dire_texte(" invité",$chaine);
echo $chaine;
?>
Fonctions
• Passage des paramètres d’une fonction par référence :
<?php
function dire_texte($qui, &$texte){
$texte = "Bienvenue $qui";
}
$chaine = "Bonjour ";
echo $chaine;
dire_texte(" invité",$chaine);
echo $chaine;
?>
• PHP supporte la notion d’appel récursifs des fonctions.
Fonctions
• Appel dynamique de fonctions : Exécuter une fonction dont le
nom n’est pas forcément connu à l’avance, en suivant le nom
d’une variable contenant le nom de la fonction.
<?php
$datejour = getdate() ; // date actuelle
$heure=$datejour["hours"]; // Récupérer l’heure actuelle
function bonjour(){
global $heure;
echo "<b>Bonjour, il est: ", $heure,"</b><br/>"; }
function bonsoir (){
global $heure;
echo "<b>Bonsoir, il est: ", $heure,"</b><br/>"; }
if($heure<=17){ $salut="bonjour"; }else{ $salut="bonsoir"; }
$salut() ; //appel dynamique de la fonction
?>
Fonctions
• Une variables en PHP : global, static, local.
• Toute variable déclarée en dehors d’une fonction est globale.
• Pour utiliser une variable globale dans une fonction, faut
utiliser l’instruction global suivie du nom de la variable.
• Pour conserver la valeur acquise par une variable entre deux
appels de la même fonction : l’instruction static.
Fonctions
• Les variables statiques restent locales à la fonction et ne sont
pas réutilisables à l’extérieur.
<?php
function cumul ($prix) {
static $cumul = 0 ;
static $i = 1 ;
echo "Total des achats $i = ";
$cumul += $prix; $i++ ;
return $cumul ;
}
echo cumul(175),"<br />";
echo cumul (65), "<br />" ;
echo cumul (69), "<br />" ;
?>
Typage des fonctions
• Spécifier les types de données attendus en entrée (paramètres)
et renvoyés en sortie (valeur de retour).
• entier (int), chaîne (string), à virgule flottante (float), booléen
(bool), tableau (array), objet (object), …
• Amélioration de la lisibilité du code.
• Prévention des erreurs de type lors de l'appel de fonctions.
• Documentation automatique du code grâce aux types.
Typage des fonctions
• Spécifier les types de données attendus en entrée (paramètres)
et renvoyés en sortie (valeur de retour).
• entier (int), chaîne (string), à virgule flottante (float), booléen
(bool), tableau (array), objet (object), …
• Amélioration de la lisibilité du code.
• Prévention des erreurs de type lors de l'appel de fonctions.
• Documentation automatique du code grâce aux types.
<?php
function nomFonction(type1 $arg1, type2 $arg2, … )
{ ... }
?>
Typage des fonctions
• Spécifier les types de données attendus en entrée (paramètres)
et renvoyés en sortie (valeur de retour).
• entier (int), chaîne (string), à virgule flottante (float), booléen
(bool), tableau (array), objet (object), …
• Amélioration de la lisibilité du code.
• Prévention des erreurs de type lors de l'appel de fonctions.
• Documentation automatique du code grâce aux types.
<?php
function nomFonction( … ) : typeRetour
{ ... }
?>
Typage des fonctions
• L'introduction de types de retour nul (nullable) en PHP permet
de gérer de manière explicite les cas où une fonction peut
retourner une valeur nulle (null).
• Ils permettent de clarifier le comportement attendu des
fonctions en indiquant clairement qu'une fonction peut
renvoyer une valeur de type donné ou null.
<?php
function nomFonction( … ) : ?typeRetour
{ ... }
?>
Fonctions anonymes
• Également connues sous le nom de closures, sont créées en
utilisant le mot-clé function sans nom pour la fonction.
• Souvent utilisées pour définir des fonctions de rappel (callbacks)
ou pour encapsuler une logique à un endroit précis du code.
<?php
$maFonction = function () {
echo "Ceci est une fonction anonyme.";
};
// Appel de la fonction anonyme
$maFonction();
?>
Fonctions anonymes
• Également connues sous le nom de closures, sont créées en
utilisant le mot-clé function sans nom pour la fonction.
• Souvent utilisées pour définir des fonctions de rappel (callbacks)
ou pour encapsuler une logique à un endroit précis du code.
<?php
$addition = function ( $a , $b) {
return $a+$b;
};
// Appel de la fonction anonyme
$addition( 2, 5);
?>
Fonctions anonymes
• Les fonctions anonymes peuvent capturer des variables de leur
portée environnante (portée lexique) pour les utiliser à
l'intérieur de la fonction. Cela est utile pour créer des
fermetures (closures).
<?php
$x = 10;
$maClosure = function ($y) use ($x) {
return $x + $y;
};
$resultat = $maClosure(5);
?>
Fonctions anonymes
• Les fonctions anonymes sont souvent utilisées comme rappels
(callback) pour des fonctions qui acceptent des fonctions de
rappel:
<?php
$x = [1, 2, 3, 4, 5];
$carres = array_map(
function ($nombre) {
return $nombre * $nombre;
}
, $nombres);
?>
Fonctions anonymes
• Les fonctions anonymes peuvent être stockées dans des
tableaux ou des variables :
<?php
$operations = [
‘addition’ => function ($a, $b) { return $a + $b; },
‘difference’ => function ($a, $b){ return $a - $b;}
];
$resultat = $operations[‘addition’](5, 3);
?>
Fonctions: Exercice
• Créez un tableau associatif pour stocker les contacts (un
nom, un numéro de téléphone et une adresse email).
<?php $contacts = array(); ?>
• Implémentez les fonctions suivantes :
o ajouterContact($nom, $telephone, $email)
o rechercherContact($nom)
o afficherContacts()
• Utilisez un formulaire HTML pour permettre à l'utilisateur
d'ajouter de nouveaux contacts, et l’afficher sous forme de
tableau sur la page Web.
