Syntaxe de base de PHP : variables, fonctions, conditions et boucles

Introduction

Bienvenue dans ce cours essentiel sur la syntaxe de base de PHP ! Même si notre objectif est l'apprentissage avancé de la programmation backend avec Laravel, une maîtrise solide des fondations de PHP est indispensable. Laravel, étant un framework PHP, est construit sur ces concepts fondamentaux. Comprendre comment les variables sont gérées, comment les fonctions sont déclarées et utilisées, et comment le flux d'exécution est contrôlé par les conditions et les boucles, vous permettra non seulement de lire et d'écrire du code PHP efficace, mais aussi de comprendre plus profondément le fonctionnement interne de Laravel.

PHP est un langage à typage dynamique et faible. Cela signifie que vous n'avez pas besoin de spécifier explicitement le type d'une variable lors de sa déclaration (il est déterminé à l'exécution), et qu'il peut y avoir des conversions implicites de types. Cette flexibilité apporte de la rapidité de développement, mais aussi la nécessité d'être vigilant sur les types de données manipulés.

Plongeons dans les bases !

1. Les variables en PHP

Une variable est un conteneur pour stocker des informations. En PHP, les variables sont faciles à reconnaître et à utiliser.

1.1 Déclaration et assignation

Toutes les variables en PHP commencent par le signe dollar ($). Elles sont sensibles à la casse ( $maVariable est différent de $mavarable).

<?php
// Déclaration et assignation
$nom = "Alice"; // Variable de type chaîne de caractères (string)
$age = 30; // Variable de type entier (integer)
$prixUnitaire = 19.99; // Variable de type nombre à virgule flottante (float)
$estActif = true; // Variable de type booléen (boolean)
$couleurs = ["rouge", "vert", "bleu"]; // Variable de type tableau (array)
$objetUtilisateur = new stdClass(); // Variable de type objet (object)
$variableNulle = null; // Variable de type nul (null)

echo "Nom : " . $nom . "\n";
echo "Âge : " . $age . "\n";
echo "Prix : " . $prixUnitaire . "\n";
echo "Est actif : " . ($estActif ? 'Oui' : 'Non') . "\n";
echo "Première couleur : " . $couleurs[0] . "\n";
echo "Type de \$objetUtilisateur : " . gettype($objetUtilisateur) . "\n";
echo "Type de \$variableNulle : " . gettype($variableNulle) . "\n";
?>

Explication du code :

Chaque variable est précédée de $.
L'opérateur = est utilisé pour l'assignation.
PHP détermine automatiquement le type de la variable en fonction de la valeur assignée (par exemple, "Alice" est une chaîne, 30 est un entier).
Nous utilisons echo pour afficher la valeur des variables. L'opérateur . est utilisé pour la concaténation de chaînes.
gettype() est une fonction utile pour connaître le type actuel d'une variable.

1.2 Portée des variables (Scope)

La portée d'une variable définit l'endroit où elle peut être accédée et utilisée dans votre code.

Locales : Déclarées à l'intérieur d'une fonction, elles ne sont accessibles que dans cette fonction.
Globales : Déclarées en dehors de toute fonction. Pour les utiliser à l'intérieur d'une fonction, vous devez utiliser le mot-clé global ou la superglobale $GLOBALS.
Statiques (static) : Utilisées à l'intérieur d'une fonction, elles conservent leur valeur entre les appels de fonction.
Superglobales : Des tableaux associatifs pré-définis par PHP qui sont toujours disponibles, quelle que soit la portée. Exemples : $_GET, $_POST, $_SERVER, $_SESSION, $_COOKIE, $_FILES, $_REQUEST, $GLOBALS. Ces variables sont cruciales en développement web pour interagir avec les requêtes HTTP et l'environnement serveur.

<?php
$messageGlobal = "Bonjour depuis l'extérieur !"; // Variable globale

function saluer() {
    $messageLocal = "Bonjour depuis la fonction !"; // Variable locale
    echo $messageLocal . "\n";

    // Pour accéder à une variable globale à l'intérieur d'une fonction, utilisez 'global'
    global $messageGlobal;
    echo $messageGlobal . "\n";

    // Ou utilisez le tableau superglobal $GLOBALS
    echo $GLOBALS['messageGlobal'] . " (via \$GLOBALS)\n";
}

saluer();
// echo $messageLocal; // Ceci provoquerait une erreur car $messageLocal n'est pas accessible ici
echo $messageGlobal . "\n"; // Ceci fonctionne car $messageGlobal est globale

function compteur() {
    static $compteurStatic = 0; // Variable statique
    $compteurStatic++;
    echo "Compteur statique : " . $compteurStatic . "\n";
}

compteur(); // Affiche : Compteur statique : 1
compteur(); // Affiche : Compteur statique : 2 (la valeur est conservée)
compteur(); // Affiche : Compteur statique : 3
?>

1.3 Constantes

Les constantes sont comme des variables, mais leur valeur ne peut pas être modifiée après leur déclaration. Elles sont souvent utilisées pour des valeurs qui ne changent jamais, comme des clés API ou des chemins de fichiers.

define() : Fonction utilisée pour définir une constante. Nom sensible à la casse par défaut, mais peut être configuré.
const : Mot-clé utilisé pour définir des constantes de classe ou des constantes de fichier. Toujours sensible à la casse.

<?php
define("MAX_UTILISATEURS", 100);
echo "Nombre maximal d'utilisateurs : " . MAX_UTILISATEURS . "\n";

const NOM_APPLICATION = "MonAppLaravel"; // Utilisé pour les constantes de fichier
echo "Nom de l'application : " . NOM_APPLICATION . "\n";

// MAX_UTILISATEURS = 150; // Ceci provoquerait une erreur fatale
?>

2. Les fonctions en PHP

Les fonctions sont des blocs de code réutilisables qui effectuent une tâche spécifique. Elles aident à organiser le code, le rendre plus lisible et plus facile à maintenir.

2.1 Déclaration de fonctions

Une fonction est déclarée en utilisant le mot-clé function, suivi du nom de la fonction, de parenthèses (pour les arguments) et d'accolades (pour le corps de la fonction).

<?php
function direBonjour() {
    echo "Bonjour le monde !\n";
}

direBonjour(); // Appel de la fonction

function saluerPersonne($nom) { // $nom est un argument
    echo "Bonjour, " . $nom . " !\n";
}

saluerPersonne("Alice"); // Appel avec un argument
saluerPersonne("Bob");
?>

2.2 Passage d'arguments

Par valeur (défaut) : Une copie de la variable est passée à la fonction. Les modifications à l'intérieur de la fonction n'affectent pas la variable originale.
Par référence (&) : La fonction travaille directement avec la variable originale. Les modifications à l'intérieur de la fonction affectent la variable originale.
Valeurs par défaut : Vous pouvez spécifier une valeur par défaut pour un argument. Si l'argument n'est pas fourni lors de l'appel de la fonction, la valeur par défaut est utilisée.

<?php
function doublerParValeur($nombre) {
    $nombre *= 2; // Modifie la copie
    echo "Dans la fonction (par valeur) : " . $nombre . "\n";
}

$valeur = 5;
doublerParValeur($valeur);
echo "Après la fonction (par valeur) : " . $valeur . "\n"; // Affiche 5, la variable originale n'est pas modifiée

function doublerParReference(&$nombre) { // Notez le &
    $nombre *= 2; // Modifie l'original
    echo "Dans la fonction (par référence) : " . $nombre . "\n";
}

$valeurRef = 5;
doublerParReference($valeurRef);
echo "Après la fonction (par référence) : " . $valeurRef . "\n"; // Affiche 10, la variable originale est modifiée

function saluerAvecDefault($nom, $prefixe = "M.") { // $prefixe a une valeur par défaut
    echo "Bonjour, " . $prefixe . " " . $nom . " !\n";
}

saluerAvecDefault("Dupont"); // Utilise le préfixe par défaut "M."
saluerAvecDefault("Durand", "Mme."); // Spécifie un préfixe différent
?>

2.3 Retour de valeurs

Le mot-clé return est utilisé pour renvoyer une valeur de la fonction. Une fonction peut renvoyer n'importe quel type de donnée.

<?php
function ajouter($a, $b) {
    return $a + $b; // Retourne la somme
}

$resultat = ajouter(10, 5);
echo "La somme est : " . $resultat . "\n"; // Affiche 15

function obtenirInfosUtilisateur($id) {
    // Imaginez ici une requête à une base de données
    if ($id == 1) {
        return ["nom" => "Alice", "age" => 30]; // Retourne un tableau
    } else {
        return null; // Retourne null si l'utilisateur n'est pas trouvé
    }
}

$utilisateur = obtenirInfosUtilisateur(1);
if ($utilisateur !== null) {
    echo "Utilisateur trouvé : " . $utilisateur['nom'] . ", " . $utilisateur['age'] . " ans.\n";
} else {
    echo "Utilisateur non trouvé.\n";
}
?>

2.4 Fonctions anonymes (Closures) et Fonctions fléchées (Arrow Functions)

PHP supporte également des fonctions plus avancées, très utilisées en programmation fonctionnelle et dans Laravel :

Fonctions anonymes (Closures) : Fonctions sans nom, souvent assignées à une variable ou passées en argument. Elles peuvent use des variables de leur portée parente.
Fonctions fléchées (Arrow Functions) : Une syntaxe plus concise pour les fonctions anonymes à une seule expression, introduites en PHP 7.4. Elles capturent automatiquement les variables utilisées dans leur portée parente.

Ces concepts seront explorés plus en détail lors de l'étude de fonctions comme array_map, array_filter, ou dans les callbacks de Laravel (par exemple, pour les routes ou les collections).

3. Les structures conditionnelles

Les structures conditionnelles permettent d'exécuter du code différemment en fonction de certaines conditions.

3.1 `if`, `else`, `elseif`

C'est la structure la plus courante pour prendre des décisions.

if (condition) : Exécute le bloc de code si la condition est true.
else : Exécute le bloc de code si la condition if (et toutes les elseif) est false.
elseif (condition) : Exécute le bloc de code si la condition if précédente était false et que la condition elseif est true.

<?php
$note = 75;

if ($note >= 90) {
    echo "Mention : Excellent !\n";
} elseif ($note >= 70) {
    echo "Mention : Bien.\n";
} elseif ($note >= 50) {
    echo "Mention : Passable.\n";
} else {
    echo "Mention : Échec.\n";
}

$estConnecte = true;
$isAdmin = false;

if ($estConnecte && $isAdmin) { // Opérateur logique ET
    echo "Accès administrateur.\n";
} elseif ($estConnecte || $isAdmin) { // Opérateur logique OU
    echo "Accès utilisateur standard.\n";
} else {
    echo "Veuillez vous connecter.\n";
}
?>

Opérateurs de comparaison courants :

== : Égalité (valeur)
=== : Identité (valeur et type)
!= ou <> : Différent de (valeur)
!== : Non identique (valeur ou type)
< : Inférieur à
> : Supérieur à
<= : Inférieur ou égal à
>= : Supérieur ou égal à

Opérateurs logiques courants :

&& (AND) : Vrai si les deux opérandes sont vraies.
|| (OR) : Vrai si au moins un des opérandes est vrai.
! (NOT) : Inverse la valeur de vérité de l'opérande.

3.2 L'opérateur ternaire

C'est une syntaxe concise pour les conditions if-else simples, utile pour l'assignation de variables.

<?php
$age = 18;
$statut = ($age >= 18) ? "Majeur" : "Mineur";
echo "Statut : " . $statut . "\n"; // Affiche : Statut : Majeur

// Null coalescing operator (PHP 7+) - équivalent de isset() ? :
$nomUtilisateur = $_GET['nom'] ?? 'Invité'; // Si $_GET['nom'] n'est pas défini ou est null, utilise 'Invité'
echo "Bonjour, " . $nomUtilisateur . "!\n";
?>

3.3 `switch`

La structure switch est utile lorsque vous avez plusieurs options possibles basées sur la valeur d'une seule expression.

<?php
$jourSemaine = "Mercredi";

switch ($jourSemaine) {
    case "Lundi":
        echo "C'est le début de la semaine de travail.\n";
        break; // Important pour éviter la "chute" vers le cas suivant
    case "Mercredi":
        echo "On est à la moitié de la semaine.\n";
        break;
    case "Vendredi":
        echo "C'est presque le week-end !\n";
        break;
    default:
        echo "C'est un autre jour de la semaine.\n";
        break;
}

$statutCode = 200;
switch ($statutCode) {
    case 200:
    case 201:
        echo "Requête réussie.\n";
        break;
    case 404:
        echo "Ressource non trouvée.\n";
        break;
    case 500:
        echo "Erreur interne du serveur.\n";
        break;
    default:
        echo "Code de statut inconnu.\n";
        break;
}
?>

Explication du code :

L'expression $jourSemaine est évaluée.
PHP compare la valeur de l'expression avec chaque case.
Si une correspondance est trouvée, le code sous ce case est exécuté.
Le mot-clé break est crucial pour sortir du bloc switch une fois qu'un case est exécuté. Sans break, PHP continuerait à exécuter le code des case suivants (comportement de "fall-through").
default est exécuté si aucune correspondance n'est trouvée.

4. Les boucles

Les boucles sont utilisées pour exécuter un bloc de code de manière répétée.

4.1 `for`

La boucle for est idéale lorsque vous savez combien de fois vous voulez itérer.

<?php
for ($i = 0; $i < 5; $i++) {
    echo "Itération for : " . $i . "\n";
}

// Exemple pour des tables de multiplication
echo "Table de 7 :\n";
for ($j = 1; $j <= 10; $j++) {
    echo "7 x " . $j . " = " . (7 * $j) . "\n";
}
?>

Explication du for :

Initialisation ($i = 0;) : Exécutée une seule fois au début de la boucle.
Condition ($i < 5;) : Évaluée avant chaque itération. Si true, la boucle continue ; si false, elle se termine.
Incrémentation/Décrémentation ($i++) : Exécutée après chaque itération.

4.2 `while`

La boucle while exécute un bloc de code tant qu'une condition spécifiée est vraie. Le code peut ne jamais s'exécuter si la condition est initialement fausse.

<?php
$compteurWhile = 0;
while ($compteurWhile < 3) {
    echo "Itération while : " . $compteurWhile . "\n";
    $compteurWhile++;
}

$nombreAleatoire = 0;
while ($nombreAleatoire < 5) {
    $nombreAleatoire = rand(1, 10); // Génère un nombre aléatoire entre 1 et 10
    echo "Nombre aléatoire : " . $nombreAleatoire . "\n";
}
echo "Le nombre aléatoire est enfin >= 5.\n";
?>

4.3 `do-while`

Similaire à while, mais garantit que le bloc de code est exécuté au moins une fois, car la condition est évaluée après la première exécution.

<?php
$compteurDoWhile = 5; // La condition est fausse dès le début
do {
    echo "Itération do-while (s'exécute au moins une fois) : " . $compteurDoWhile . "\n";
    $compteurDoWhile++;
} while ($compteurDoWhile < 3); // La condition est testée après l'exécution

$input = "";
do {
    // Ceci est un exemple simplifié pour illustrer; en vrai, on lirait de l'entrée utilisateur
    // Imaginez que vous demandez à l'utilisateur de taper 'oui'
    $input = "non"; // Simule une première entrée
    if ($input != "oui") {
        echo "Veuillez taper 'oui' pour continuer.\n";
    }
} while ($input != "oui");
echo "Merci !";
?>

4.4 `foreach`

La boucle foreach est spécialement conçue pour itérer sur les éléments de tableaux ou d'objets itérables. Elle est très utilisée en PHP, notamment avec les collections Laravel.

<?php
$fruits = ["pomme", "banane", "cerise"];

echo "Liste des fruits :\n";
foreach ($fruits as $fruit) {
    echo "- " . $fruit . "\n";
}

$utilisateur = [
    "nom" => "Alice",
    "age" => 30,
    "ville" => "Paris"
];

echo "\nInformations utilisateur :\n";
foreach ($utilisateur as $cle => $valeur) {
    echo ucfirst($cle) . " : " . $valeur . "\n"; // ucfirst() met la première lettre en majuscule
}
?>

Explication du foreach :

Première syntaxe : foreach (tableau as $valeur) parcourt chaque élément et assigne sa valeur à $valeur.
Deuxième syntaxe : foreach (tableau as $cle => $valeur) parcourt chaque élément et assigne sa clé à $cle et sa valeur à $valeur.

4.5 Mots-clés de contrôle de boucle

break : Permet de sortir immédiatement d'une boucle (ou d'un bloc switch). L'exécution continue après la boucle.
continue : Permet de sauter l'itération actuelle d'une boucle et de passer directement à l'itération suivante.

<?php
echo "Exemple avec break :\n";
for ($i = 0; $i < 10; $i++) {
    if ($i == 5) {
        echo "On arrête à 5 !\n";
        break; // Sort de la boucle for
    }
    echo "Numéro : " . $i . "\n";
}

echo "\nExemple avec continue :\n";
for ($j = 0; $j < 10; $j++) {
    if ($j % 2 == 0) { // Si j est pair
        continue; // Passe à l'itération suivante sans exécuter le code en dessous
    }
    echo "Numéro impair : " . $j . "\n";
}
?>

Conclusion

Félicitations ! Vous avez parcouru les bases essentielles de la syntaxe de PHP : les variables, les fonctions, les conditions et les boucles.

Les variables sont vos conteneurs de données, identifiables par le $.
Les fonctions vous permettent de modulariser et de réutiliser votre code, rendant vos programmes plus propres et plus efficaces.
Les conditions (if/else, switch, ternaire) sont les outils de décision qui guident le flux de votre programme.
Les boucles (for, while, do-while, foreach) vous permettent d'automatiser les tâches répétitives, notamment l'itération sur les collections de données.

Ces concepts sont les piliers de toute programmation en PHP et sont omniprésents dans un framework comme Laravel. Chaque fois que vous définirez une route, manipulerez des données de base de données, ou créerez une vue dans Laravel, vous utiliserez inconsciemment ou consciemment ces fondamentaux. Une compréhension solide de ces bases vous donnera une longueur d'avance pour aborder des concepts plus avancés comme la Programmation Orientée Objet (POO), les espaces de noms, la gestion d'erreurs, et bien sûr, la magie de Laravel.

Pratiquez-les, expérimentez avec eux, et vous serez prêt pour la prochaine étape de votre parcours backend !