PHP Academy · Leçon

Modèle de conception : séparer la logique de la vue

Déplacer la logique métier dans des fichiers PHP et conserver des modèles HTML clairs.

Leçon 4 sur 413 étapes

Modèle de conception : séparer la logique de la vue est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.

Pourquoi séparer la logique de la vue ?

Mélanger les requêtes de base de données, la logique métier et le HTML dans le même fichier entraîne :

Du code spaghetti difficile à lire
Des difficultés à tester et à réutiliser la logique
Des erreurs de sécurité lorsque la validation est omise

La solution consiste à conserver chaque préoccupation dans sa propre couche.

Le modèle de base pour les modèles

Exécutez d’abord toute la logique PHP, puis affichez le HTML :

<?php
// --- LOGIC (top) ---
require 'config.php';
$userId = (int) ($_GET['id'] ?? 0);
$user   = getUserById($userId);
if (!$user) {
    http_response_code(404);
    require '404.php';
    exit;
}
$pageTitle = 'Profile: ' . $user['name'];

// --- VIEW (bottom) ---
require 'layout/header.php';
?>
<main>
    <h1><?= htmlspecialchars($user['name']) ?></h1>
</main>
<?php require 'layout/footer.php'; ?>

Séparer les fichiers de contrôleur et de vue

Divisez le code en un fichier de contrôleur et un fichier de vue :

// profile.php (controller)
<?php
require 'config.php';
$userId = (int) ($_GET['id'] ?? 0);
$user   = getUserById($userId);
$posts  = getPostsByUser($userId);

if (!$user) { require '404.php'; exit; }

require 'views/profile.view.php';

// views/profile.view.php (view) — only HTML and echoes
// No DB calls allowed here!

Préparer les données de la vue

Formatez toutes les données dans la couche de logique avant de les transmettre à la vue :

<?php
$user = getUserById($id);

$viewData = [
    'userName'   => htmlspecialchars($user['name']),
    'avatarUrl'  => $user['avatar'] ?? '/default.png',
    'joinedDate' => date('F Y', strtotime($user['created_at'])),
    'isAdmin'    => in_array('admin', $user['roles']),
];

extract($viewData);  // Makes $userName, $avatarUrl, etc.
require 'views/profile.view.php';

Modèle avec fonction de modèle

Encapsulez le rendu de la vue dans une fonction afin de faciliter sa réutilisation :

<?php
function render(string $view, array $data = []): void {
    extract($data);  // Create variables from array
    require __DIR__ . '/views/' . $view . '.php';
}

// Usage:
render('profile', [
    'name'   => $user['name'],
    'email'  => $user['email'],
]);

Moteur de modèles avec mise en mémoire tampon

Effectuez le rendu d’un modèle et renvoyez-le sous forme de chaîne :

<?php
function renderToString(string $view, array $data = []): string {
    extract($data);
    ob_start();
    require __DIR__ . '/views/' . $view . '.php';
    return ob_get_clean();
}

$html = renderToString('email/welcome', ['name' => 'Alice']);
mail($to, 'Welcome!', $html, 'Content-Type: text/html');

Quand utiliser un moteur de modèles

Pour les sites simples, le système de modèles natif de PHP convient très bien. Envisagez Twig ou Blade lorsque :

Vous souhaitez que l’échappement soit automatique par défaut
Les concepteurs doivent modifier les modèles sans connaître PHP
Vous avez besoin de l’héritage de modèles et de macros
Le projet comporte de nombreuses vues et prend de l’ampleur

Exemple avec Twig

Twig, utilisé par Symfony, fournit une syntaxe claire avec un échappement automatique :

<?php
// After: composer require twig/twig
$loader = new Twig\Loader\FilesystemLoader('/templates');
$twig   = new Twig\Environment($loader, ['cache' => '/tmp/twig']);

echo $twig->render('profile.html.twig', [
    'user'  => $user,
    'posts' => $posts,
]);

// profile.html.twig:
// <h1>{{ user.name }}</h1>  -- auto-escaped by default

Structure de répertoires MVC

Une structure MVC minimale pour les projets PHP classiques :

project/
  controllers/
    UserController.php   -- handles request, calls model
  models/
    User.php             -- database queries
  views/
    users/
      profile.php        -- display only, no logic
  public/
    index.php            -- front controller (router)

Modèle du contrôleur frontal

Acheminez toutes les requêtes via un point d’entrée unique :

<?php
// public/index.php (front controller)
require __DIR__ . '/../vendor/autoload.php';

$uri    = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
$routes = require '../routes.php';

if (isset($routes[$uri])) {
    [$controller, $action] = $routes[$uri];
    (new $controller)->$action();
} else {
    http_response_code(404);
    require '../views/404.php';
}

Principe de responsabilité unique

Chaque fichier ne devrait avoir qu’une seule raison de changer :

Modèle : change uniquement lorsque la structure des données ou la logique des requêtes change
Contrôleur : change uniquement lorsque la logique de traitement des requêtes change
Vue : change uniquement lorsque l’interface utilisateur ou la mise en page change

Cela permet de tester et de maintenir plus facilement chaque élément indépendamment.

Vérification rapide

Quel est le principal avantage de séparer la logique PHP du code HTML de la vue ?

Réponds-y dans la leçon interactive

Récapitulatif : modèle de modèles

Points essentiels :

Exécutez d’abord toute la logique, puis affichez le HTML
Séparez le code en fichiers de contrôleur et de vue
Utilisez une fonction render() avec extract()
La mise en mémoire tampon capture le HTML généré
Envisagez Twig ou Blade pour les projets de grande taille
Le contrôleur frontal achemine toutes les requêtes vers des gestionnaires

Gratuit pour commencer

Apprends PHP avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 49
Leçons: 195

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Modèle de conception : séparer la logique de la vue » est-elle gratuite ?

Oui — le texte complet de « Modèle de conception : séparer la logique de la vue » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Modèle de conception : séparer la logique de la vue » ?

Déplacer la logique métier dans des fichiers PHP et conserver des modèles HTML clairs. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PHP Academy ?

Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Modèle de conception : séparer la logique de la vue » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?

Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Balises PHP et syntaxe d’intégration
HTML dynamique avec les boucles PHP
Inclure et exiger des fichiers
Modèle de conception : séparer la logique de la vue

← Retour à PHP Academy