2) Conditions, boucles & priorité logique

Conditions

<?php
if ($prix > 100) {
    echo "Livraison gratuite !";
} elseif ($prix > 50) {
    echo "Réduction de 10%";
} else {
    echo "Pas de promotion";
}
?>

Boucles classiques

for

<?php
for ($i = 1; $i <= 5; $i++) {
    echo "Produit numéro $i<br>";
}
?>

while

<?php
$stock = 3;
while ($stock > 0) {
    echo "Un produit vendu, reste $stock<br>";
    $stock--;
}
?>

do…while

<?php
$compteur = 0;
do {
    echo "Exécution n°$compteur<br>";
    $compteur++;
} while ($compteur < 3);
?>

Boucle sur collections : foreach

<?php
$articles = ["Clavier" => 59.99, "Souris" => 29.99];
foreach ($articles as $nom => $p) {
    echo "$nom : $p €<br>";
}
?>

il faut bien rappeler que PHP gère deux types de tableaux :

• tableaux indicés (clés numériques automatiques → 0, 1, 2, …)

• tableaux associatifs (clés choisies → chaînes ou entiers)

Exemple de foreach avec un tableau indicé

<?php
$fruits = ["Pomme", "Banane", "Cerise"];
foreach ($fruits as $index => $valeur) {
    echo "Index $index : $valeur<br>";
}
?>

Priorité des opérateurs logiques (très important)

&& et || ont une priorité plus forte que and et or. Préférer && et || dans les conditions.

<?php
$a = true; $b = false;

$result1 = $a && $b; // false
$result2 = $a and $b; // interprété comme ($result2 = $a) and $b → $result2 vaut true
echo $result2 ? "true" : "false"; // affiche true
?>

3) Fonctions, typage & PHPDoc

Depuis PHP 7+, on peut typer paramètres et valeur de retour. PHPDoc améliore la lisibilité et les outils.

Fonction avec typage + PHPDoc

<?php
define("TVA", 0.20);

/**
 * Calcule le prix TTC.
 *
 * @param float $prixHT Prix hors taxes
 * @return float Prix TTC
 */
function prixTTC(float $prixHT): float {
    return $prixHT * (1 + TVA);
}

echo prixTTC(100); // 120
?>

Variables locales vs globales (à éviter si possible)

<?php
$remise = 0.1; // globale

/**
 * Applique une remise globale (exemple pédagogique)
 *
 * @param float $prix
 * @return float
 */
function prixRemise(float $prix): float {
    global $remise; // préférez passer $remise en paramètre
    return $prix * (1 - $remise);
}
?>

Bonne pratique : passer la remise en paramètre plutôt que d’utiliser global.

4) Formulaires & sécurisation (10 min)

Formulaire HTML

<form method="post" action="traitement.php">
  <label>Produit :</label>
  <input type="text" name="produit">
  <label>Quantité :</label>
  <input type="number" name="quantite" min="1">
  <button type="submit">Commander</button>
</form>

Traitement sécurisé côté PHP

<?php
/**
 * Nettoie une entrée texte (trim + échappement HTML)
 *
 * @param string $data
 * @return string
 */
function nettoyer(string $data): string {
    return htmlspecialchars(trim($data), ENT_QUOTES, 'UTF-8');
}

$produit  = isset($_POST['produit']) ? nettoyer($_POST['produit']) : '';
$quantite = isset($_POST['quantite']) ? (int) $_POST['quantite'] : 0;

if (!empty($produit) && $quantite > 0) {
    echo "Commande : $quantite x $produit";
} else {
    echo "Formulaire incomplet.";
}
?>

Superglobales utiles : $_GET, $_POST, $_REQUEST, $_SERVER, $_FILES, $_COOKIE.

5) PDO & requêtes préparées

Connexion & requête préparée

<?php
try {
    $pdo = new PDO("mysql:host=localhost;dbname=ecommerce;charset=utf8", "root", "");
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    /**
     * Récupère les produits en dessous d’un prix max.
     *
     * @param PDO   $pdo
     * @param float $max
     * @return array
     */
    function getProduits(PDO $pdo, float $max): array {
        $sql = "SELECT nom, prix FROM produits WHERE prix < :max";
        $stmt = $pdo->prepare($sql);
        $stmt->execute([":max" => $max]);
        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    }

    foreach (getProduits($pdo, 100) as $row) {
        echo $row['nom'] . " - " . $row['prix'] . " €<br>";
    }

} catch (PDOException $e) {
    echo "Erreur : " . htmlspecialchars($e->getMessage(), ENT_QUOTES, 'UTF-8');
}
?>

Pourquoi préparées ? Pour éviter les injections SQL et bénéficier d’un binding typé.

6) Gestion de fichiers (lecture/écriture)

Lecture ligne à ligne

<?php
$handle = fopen("produits.txt", "r");
if ($handle) {
    while (($line = fgets($handle)) !== false) {
        echo htmlspecialchars($line) . "<br>";
    }
    fclose($handle);
}
?>

Écriture (append)

<?php
$handle = fopen("produits.txt", "a");
if ($handle) {
    fwrite($handle, "Souris;29.99\n");
    fclose($handle);
}
?>

Usages typiques : logs, exports simples, stockage temporaire.

7) Factoriser avec include & require

include est tolérant (warning si fichier manquant, le script continue). require est strict (erreur fatale si manquant).

Exemple

<!-- header.php -->
<?php echo "<h1>Mon site e-commerce</h1><hr>"; ?>

<!-- index.php -->
<?php
include __DIR__ . "/header.php";   // continue si manquant
require __DIR__ . "/config.php";   // stoppe si manquant (utile pour la config indispensable)
?>

Astuce : utiliser __DIR__ pour des chemins robustes.

8) Astuces & mots-clés indispensables

• Tests : isset(), empty()
• Debug : var_dump(), print_r()
• Chaînes : explode(), implode(), concaténation avec .
• Dates : date("d/m/Y H:i")
• Constantes magiques : __FILE__, __DIR__, __LINE__
• Mots-clés : function, return, global, const, define, try/catch, if/elseif/else, for/foreach/while, include/require

9) Conclusion

Nous avons revu : variables, constantes, fonctions (typage & PHPDoc), portée, formulaires sécurisés, PDO, priorité logique, fichiers, include/require.