Tronc commun / B1 / Développement / PHP

PHP

1. Concepts de base

PHP (PHP: Hypertext Preprocessor) est un langage de script côté serveur, open source, conçu pour créer des pages web dynamiques.

Le code PHP inséré dans une page s'exécute à chaque chargement / rafraîchissement de la page (F5).

Cycle d'une page dynamique :

Action utilisateur → Requête HTTP → Traitement du PHP (serveur) → Affichage de la page

2. Syntaxe procédurale

Bloc de code

<?php
// mon code ici
?>

Peut être le seul contenu du fichier, ou mélangé à du HTML.

Afficher une valeur

<?php
echo "Bonjour tout le monde";
?>

Variables

$monNom = "Dupont";   // préfixées par $

• Sensibles à la casse ($nom ≠ $Nom).
• Convention : jamais de majuscule en première lettre.
• Le type est défini automatiquement à la première utilisation.
• Portée : le script entier dans lequel elles sont définies.
• Variables superglobales ($_GET, $_POST, $_SESSION, $_SERVER…) : mises en place automatiquement par Apache, accessibles partout.
• Fonctions utiles : var_dump($var) (type + valeur), isset($var) (la variable est-elle définie ?).

Types de données

• Scalaires : int, float, string, bool.
• Composés : array, object.
• Chaînes : délimitées par guillemets simples '...' ou doubles "..." (les doubles interprètent les variables à l'intérieur).

Constantes

define("TVA", 0.20);   // convention : nom en MAJUSCULES, valeur non modifiable

Opérateurs

+ - * / %      // arithmétiques
=              // affectation
&& / and       // ET logique
|| / or        // OU logique

Tableaux

$fruits = ["pomme", "poire", "banane"];      // tableau indexé (indice = int)
$personne = ["nom" => "Dupont", "age" => 30]; // tableau associatif (clé = string)

Structures conditionnelles

if ($nombre < 0) {
    echo "Négatif";
} elseif ($nombre == 0) {
    echo "Nul";
} else {
    echo "Positif";
}

switch ($operande) {
    case 1:
        echo "Un";
        break;
    default:
        echo "Autre";
}

Structures itératives

// Nombre d'itérations déterminé
for ($i = 0; $i <= 100; $i++) {
    echo $i;
}

// Nombre d'itérations indéterminé
$n = 100;
while ($n > 0) {
    echo $n;
    $n -= 2;
}

Fonctions utilisateur

function addition($a, $b) {
    return $a + $b;   // return arrête l'exécution et renvoie la valeur
}

• Passage par valeur (par défaut) : la fonction reçoit une copie de la variable.
• Passage par référence (function f(&$a)) : la fonction modifie directement la variable d'origine.

Inclusion de fichiers

include 'header.php';       // avertissement si absent, poursuit l'exécution
include_once 'header.php';  // évite les doublons d'inclusion
require 'config.php';       // erreur fatale si absent, arrête le script
require_once 'config.php';

Un fichier inclus peut contenir du HTML, du PHP, ou les deux ; le HTML est intégré tel quel dans la page envoyée au navigateur. include_once / require_once sont recommandés pour les fichiers de constantes/fonctions, afin d'éviter les redéclarations.

3. Syntaxe orientée objet (POO)

Visibilité des attributs/méthodes

Constructeur / destructeur

class Personne {
    public function __construct($nom, $prenom) {
        $this->nom = $nom;
        $this->prenom = $prenom;
    }

    public function __destruct() {
        // libère des ressources — méthode facultative
    }
}

$p = new Personne("Dupont", "Marie");

• Le constructeur porte toujours le nom __construct.
• Le destructeur (__destruct) est appelé automatiquement en fin de vie de l'objet.

Méthodes magiques

Méthodes au nom réservé, appelées automatiquement par PHP dans certains contextes : __construct(), __destruct(), __get(), __set(), __isset(), __unset(), __call(), __callStatic(), __toString(), __sleep(), __wakeup(), __serialize(), __unserialize()…

4. Manipulation de fichiers

Fichiers plats / CSV

// Lecture ligne à ligne
$monFichier = fopen('./liste.csv', 'r');
while (!feof($monFichier)) {
    $ligne = fgetcsv($monFichier);
    // traitement de $ligne (tableau)
}
fclose($monFichier);

// Écriture (ajout en fin de fichier)
$monFichier = fopen('./liste.csv', 'a');
fwrite($monFichier, "valeur1;valeur2\n");
fclose($monFichier);

• fopen(fichier, mode) : 'r' lecture, 'a' ajout, 'w' écriture (écrase).
• feof($fichier) : vrai si on est arrivé en fin de fichier.

Fichiers XML — l'API DOM

$monXML = new DomDocument();
$monXML->load('fichier.xml');

$racine = $monXML->documentElement;   // élément racine
$liste  = $racine->getElementsByTagName('groupe'); // DomNodeList

Étapes de lecture : déclarer l'objet DomDocument → charger le fichier → parcourir l'arbre.

5. Formulaires côté PHP

// Méthode GET (visible dans l'URL, taille limitée)
// maPage.php?classe=SIO1&lycee=EllaFitzgerald
$classe = $_GET['classe'] ?? '';

// Méthode POST (corps de la requête, taille illimitée)
$nom = $_POST['nom'] ?? '';

// Toujours tester l'existence du paramètre avant de l'utiliser
if (isset($_POST['nom'])) {
    echo $_POST['nom'];
}

• GET : données dans l'URL, on peut construire un lien <a href="page.php?param=valeur">.
• POST : données dans $_POST, invisibles dans l'URL.
• isset($var) évite les erreurs si le paramètre n'a pas été envoyé ; l'opérateur ?? '' fait la même chose de façon plus concise.

6. Accès aux bases de données — PDO

Modalités d'accès existantes : natif (MySQLi), ODBC, SQLite embarqué, PDO (API commune à plusieurs SGBD — la plus utilisée).

Requête directe vs requête préparée : dans une requête préparée, le SGBD compile la requête à l'avance et les valeurs sont injectées séparément → protection contre les injections SQL.

// 1. Connexion
$cnx = new PDO('mysql:dbname=' . BDD . ';host=' . HOST . ';port=' . PORT, LOGIN, PASSW);

// 2. Préparation de la requête (paramètres sécurisés avec :nom ou ?)
$req = $cnx->prepare("SELECT * FROM candidat WHERE numCandidat = :id");
$req->execute(['id' => $idRecherche]);

// 3. Récupération du résultat
$ligne = $req->fetch();          // une seule ligne
$toutes = $req->fetchAll();      // toutes les lignes

Gestion des erreurs — try/catch

try {
    $cnx = new PDO('mysql:dbname=' . BDD . ';host=' . HOST, LOGIN, PASSW);
} catch (PDOException $e) {
    echo "Erreur de connexion : " . $e->getMessage();
}

try / catch permet de récupérer et traiter les événements extérieurs qui perturberaient l'exécution normale du script.

7. Sessions PHP

Une session correspond à la période de navigation continue d'un utilisateur sur un site : elle permet de conserver des variables d'une page à l'autre.

// Toujours en tout premier, avant tout affichage
session_start();

// Création / écriture d'une variable de session
$_SESSION['maVariable'] = $valeur;

// Lecture
echo $_SESSION['maVariable'];

// Destruction de la session
session_destroy();

Les 3 étapes d'une session :

1. Création : le visiteur arrive, le serveur Apache génère un espace de stockage et un identifiant de session.
2. Exploitation : on peut créer autant de variables $_SESSION[...] que nécessaire.
3. Destruction : à la déconnexion, Apache détruit toutes les variables de session créées.

8. Framework Laravel

Notions préalables

Laravel est un framework PHP orienté objet, respectant l'architecture MVC, distribué sous licence libre MIT.

Installation

Se fait via un environnement de développement local dédié (ex. Laragon) + Composer pour gérer les dépendances du projet.

Arborescence MVC

app/...                      → Modèles
resources/views/...          → Vues
app/Http/Controllers/...     → Contrôleurs
routes/web.php               → Routes

Routes

// routes/web.php
Route::get('/eleves/{classe}', [EleveController::class, 'index'])->name('eleves.index');

// Regrouper des routes qui partagent les mêmes contrôles
Route::group(['middleware' => 'auth'], function () {
    // ...
});

• Une route associe une URL à un bout de code (en général un contrôleur).
• On peut nommer les routes pour simplifier leurs appels ailleurs dans l'app.
• Le type resource génère en une seule commande toutes les routes CRUD standard.
• php artisan route:list liste toutes les routes du projet.

Contrôleurs

// Dans le contrôleur
use App\Models\MonModele;

public function index($classe)
{
    $donnees = MonModele::all();
    return view('eleves.index', ['donnees' => $donnees, 'classe' => $classe]);
}

• On peut associer un middleware à un contrôleur pour la sécurité/les contrôles.
• Les arguments d'URL sont transmis directement en paramètres de la fonction.

Vues — moteur de template Blade

@extends('layouts.app')

@section('contenu')
    <p>Bonjour {{ $prenom }}</p>
    @php
        $total = 10 + 5;
    @endphp
@endsection

Blade repose sur Bootstrap et reste simple d'utilisation ; @extends gère l'héritage de template, @php ... @endphp permet d'insérer du PHP classique.

Modèles & migrations

// Migration : gestion incrémentale de la structure de la BdD
public function up()
{
    Schema::create('eleves', function (Blueprint $table) {
        $table->id();
        $table->string('nom');
    });
}

// Insertion
$monAjout = App\Models\MonModel::create(['nom' => 'Clerc']);

// Recherche
$maDonnee = App\Models\MonModel::find($monId);

• Un modèle correspond à une table de la BdD.
• Les migrations versionnent les évolutions de structure de la base, pour garder le code et la BdD synchronisés.
• Par défaut, les données sont protégées (on ne peut pas modifier leur valeur "en dur" sans passer par les mécanismes du modèle).