Les conditions

→ if

L’instruction if (si en français) est une des plus importantes instructions de tous les langages. Elle permet l’exécution conditionnelle d’une partie de code. Elle se rédige comme suit :

if (/*expression*/)
{
	// instructions
}

expression doit toujours être équivalent à un booléen (true ou false). Pour se faire, expression contiendra le plus souvent des opérateurs de comparaison.
Si l’expression est valide (équivalente à true), alors les instructions dans les accolades sont exécutées.
Si l’expression n’est pas valide, (équivalente à false), alors les instructions ne sont pas exécutées.

Pour une meilleure compréhension il peut être utile de lire littéralement la structure :
“Si l’expression est valide (égale à true) alors j’exécute les instructions“.

→ else

else (sinon en français) fonctionne après un if et exécute les instructions correspondantes au cas où l’expression du if est false. En effet, il est intéressant de pouvoir exécuter une instruction si une condition est remplie, et une autre instruction si cette condition n’est pas remplie.

if (/*expression*/)
{
	// instructions A
}
else
{
	// instructions B
}

Dans cet exemple, dans le cas où l’expression est équivalente à true, les instructions A s’exécuteront, mais dans le cas où l’expression est équivalente à false les instructions B seront exécutées.
Il est important de noter que seulement une des deux instructions A ou B sera exécutée.

Pour une meilleure compréhension il peut être utile de lire littéralement la structure :
“Si l’expression est valide (égale à true) alors j’exécute les instructions A, sinon j’exécute les instructions B“.

→ elseif ou else if

elseif (Sinon si en français), comme son nom l’indique, est une combinaison de if et de else. Comme l’expression else, il permet d’exécuter une instruction après un if dans le cas où le “premier” if est évalué comme false. Mais, à la différence de l’expression else, il n’exécutera l’instruction que si l’expression conditionnelle elseif est évaluée comme true.

if (/*expression 1*/)
{
	// instructions A
}
else if (/* expression 2*/)
{
	// instructions B
}
else
{
	// instructions C
}

Pour une meilleure compréhension il peut être utile de lire littéralement la structure :
“Si l’expression 1 est valide (égale à true) alors j’exécute les instructions A, sinon si l’expression 2 est valide (égale à true) alors j’exécute les instructions B, sinon j’exécute les instructions C“.

→ switch

L’instruction switch équivaut à une série d’instructions if. La seule différence avec un if est qu’un switch ne peut vérifier qu’une équivalence.

//$nbr un nombre entier
if ($nbr == 1)
{
	// instructions A
}
else if ($nbr == 2)
{
	// instructions B
}
else
{
	// instructions C
}

Donnerait avec un switch :

//$nbr un nombre entier
switch $(nbr)
{
    case 1:
        // instructions A
        break;
    case 2:
        // instructions B
        break;
    default:
        // instructions C
}

Vous trouverez une explication du mot-clef break à la fin de la page.

Pour une meilleure compréhension il peut être utile de lire littéralement la structure :
“Pour le cas où la variable $nbr est égale à 1 alors j’exécute les instructions A, pour le cas où la variable $nbr est égale à 2 alors j’exécute les instructions B, sinon j’exécute les instructions C“.

Les boucles

→ while

La boucle while (tant que en français) est le moyen le plus simple d’implémenter une boucle en PHP.

while (/*expression*/)
{
    // instruction
}

La signification d’une boucle while est très simple. PHP exécute l’instruction tant que l’expression de la boucle while est évaluée comme true. La valeur de l’expression est vérifiée à chaque début de boucle, et, si la valeur change durant l’exécution de l’instruction, l’exécution ne s’arrêtera qu’à la fin de l’itération (chaque fois que PHP exécute l’instruction, on appelle cela une itération). De temps en temps, si l’expression du while est false avant la première itération, l’instruction ne sera jamais exécutée. Et inversement, dans le cas où l’expression du while est true de façon permanente, le code par dans une boucle infinie et la plupart du temps plante.

Pour une meilleure compréhension il peut être utile de lire littéralement la structure :
“Tant que l’expression est équivalente à true j’exécute l’instruction“.
Pour information, il existe majoritairement deux types de boucles while :

// Celles avec un compteur
$count = 0;
while ($count < 100)
{
    // instructions
    $count++;
}

// Celles sans compteur
while ($booleen == true)
{
    // instructions
}

→ do-while

Les boucles do-while (Faire, tant que en français) ressemblent beaucoup aux boucles while, mais l’expression est testée à la fin de chaque itération plutôt qu’au début. La principale différence par rapport à la boucle while est que la première itération de la boucle do-while est toujours exécutée (l’expression n’est testée qu’à la fin de l’itération), ce qui n’est pas le cas lorsque vous utilisez une boucle while (la condition est vérifiée dès le début de chaque itération, et si elle s’avère false dès le début, la boucle sera immédiatement arrêtée).

do
{
	// instruction
} while (/* expression */);

Pour une meilleure compréhension il peut être utile de lire littéralement la structure :
“J’exécute l‘instruction et tant que l’expression est équivalente à true je continue d’exécuter l’instruction“.

→ for

Les boucles for (pour en français) sont les boucles les plus complexes en PHP.

for (/* initialisation */ ; /* expression */ ; /* finition */)
{
	// instructions
}

L’initialisation est exécutée quoi qu’il arrive au début de la boucle, une seule et unique fois.
L’expression est évaluée au début de chaque itération.
La finition est exécutée à la fin de chaque itération.
Ces trois paramètres peuvent éventuellement être laissés vides ou peuvent contenir plusieurs consignes séparées par des virgules.
Attention cependant, si expression est vide, la boucle sera infinie.

Pour une meilleure compréhension il peut être utile de lire littéralement la structure :
“J’exécute l’initialisation puis tant que l’expression est équivalente à true j’exécute les instructions puis la finition“. Cas pratique :

for ($i = 0;$i < 10;$i++)
{
	// instructions
}

Pour une meilleure compréhension il peut être utile de lire littéralement la structure : “Pour $i égal 0, tant que $i est inférieur à 10 : j’exécute les instructions puis j’incrémente $i“.

→ foreach

La structure de langage foreach (Pour chaque en français) fournit une façon simple de parcourir des tableaux. foreach ne fonctionne que pour les tableaux (array) et les objets (object), et émettra une erreur si vous tentez de l’utiliser sur une variable de type différent ou une variable non initialisée. Il existe deux syntaxes :

// $tableau étant un tableau contenant un nombre fini d'éléments
foreach ($tableau AS $valeur)
{
	// instructions
}

Nous avons accès directement à $valeur qui est une variable contenant un élément de mon tableau.

// $tableau étant un tableau contenant un nombre fini d'éléments
foreach ($tableau AS $clef => $valeur)
{
	// instructions
}

Nous avons accès directement à $valeur qui est une variable contenant un élément de mon tableau ainsi qu’à $clef qui est une variable contenant la clef associée à ma valeur.

Pour une meilleure compréhension il peut être utile de lire littéralement la structure :
“Pour chaque élément dans la variable $tableau j’exécute les instructions“.

Les Mots-clefs

→ break

L’instruction break (Rompre en français) permet de sortir d’une structure for, foreach, while, do-while ou switch.

while (/* expression */)
{
	// instructions A
	break;
	// instructions B
}

Les instructions A ne seront exécutées qu’une seule et unique fois, car le break nous permet de sortir directement de la boucle while. Les instructions B n’étant pas exécutées.

→ continue

L’instruction continue (Poursuivre en français) 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.

while (/* expression */)
{
	// instructions A
	continue;
	// instructions B
}

Les instructions A seront exécutées tant que l’expression est équivalente à true, cependant les instructions B ne seront pas exécutées étant donné que continue permet de retourner directement à la vérification de l’expression pour recommencer une itération.

→ return

return (Retourner en français) retourne le contrôle du programme au module appelant reprenant ainsi l’exécution à cet endroit.
Si appelée depuis une fonction, la commande return termine immédiatement la fonction, et retourne l’argument qui lui est passé.
Si appelée depuis l’environnement global (c’est-à-dire hors d’une fonction), l’exécution du script est interrompue.

function maFonction()
{
	// Initialisation d'une variable $resultat;
	// instructions B
    return $resultat;
	// instructions C
}
// instructions A
$res = maFonction();
// instructions D

Les instructions A sont exécutées, puis la fonction maFonction est appelée.
Les instructions B sont exécutées, puis la fonction retourne le contenu de la variable $resultat qui est stocké dans la variable $res.
Les instructions D sont alors exécutées.
La directive return ayant été appelée dans une fonction, les instructions C situées après ne seront jamais exécutées.

// instructions A
return;
// instructions B

Les instructions A sont exécutées. Puis le programme quitte. Les instructions B ne seront donc jamais exécutées.

→ include

L’instruction de langage include (Inclure en français) inclut et exécute le fichier spécifié en argument.

include("monfichier.php");

Le contenu du fichier monfichier.php est lu et exécuté comme si l’intégralité du fichier remplaçait cette ligne.
En cas d’erreur (fichier introuvable ou droits insuffisants), une erreur de type Warning est envoyée mais la suite du code continue d’être exécutée.

→ require

require (Nécessite en français) est identique à include mis à part qu’en cas d’échec, l’erreur envoyée est de type Fatal.

require("monfichier.php");

Le contenu du fichier monfichier.php est lu et exécuté comme si l’intégralité du fichier remplaçait cette ligne.
En cas d’erreur (fichier introuvable ou droits insuffisants), une erreur de type Fatal est envoyée et l’exécution du code s’arrête.

→ include_once

La structure include_once (Inclure une seule fois en français) inclut et évalue le fichier spécifié durant l’exécution du script. Le comportement est similaire à include, mais la différence est que si le code a déjà été inclus, il ne le sera pas une seconde fois.

include_once("monfichier.php");

→ require_once

La structure require_once (Nécessite une seule fois en français) inclut et évalue le fichier spécifié durant l’exécution du script. Le comportement est similaire à require, mais la différence est que si le code a déjà été inclus, il ne le sera pas une seconde fois.

require_once("monfichier.php");

Les Structures de contrôles

Objectifs