Routes

Nous allons maintenant passer à la mise en place du routage. Après avoir redirigé toutes les requêtes vers index.php et supprimé les extensions .php des liens, nous pouvons contrôler précisément quelle URL correspond à quelle ressource. Le routage nous permettra de créer des URLs personnalisées, lisibles et indépendantes de la structure des fichiers, en associant chaque URL à un contrôleur et à une action définis dans un tableau de routes.

Méthodeapp/routes.php

Exemples de routes :

  • utilisateurs → [utilisateur, index]

  • utilisateur/afficher-3 → [utilisateur, show]

1
<?php
2
$routes = [];
3
// $routes[] = [path, name, [controller, action]];
4
// path : url de la ressource. {param} indique l'utilisation d'un paramètre
5
// name : clé unique de la route
6
// controller : dossier où se trouve réllement la ressource
7
// action : nom du fichier de la ressource sans son extension
8
$routes[] = ['/', 'home.index', ['home', 'index']];
9
$routes[] = ['/utilisateurs', 'utilisateur.index', ['utilisateur', 'index']];
10
$routes[] = ['/utilisateur/ajouter', 'utilisateur.create', ['utilisateur', 'create']];
11
$routes[] = ['/utilisateur/afficher-{id}', 'utilisateur.show', ['utilisateur', 'show']];
12
$routes[] = ['/utilisateur/modifier-{id}', 'utilisateur.update', ['utilisateur', 'update']];
13
$routes[] = ['/utilisateur/supprimer-{id}', 'utilisateur.delete', ['utilisateur', 'delete']];

path : le chemin de l’URL

  • Définition : C’est l’URL publique qui sera utilisée par les visiteurs pour accéder à la ressource.

  • Format : Chaîne commençant par /, avec possibilité de paramètres dynamiques indiqués par {param}.

  • Paramètres dynamiques :

    • Tout segment entouré de {} devient une variable capturable.

    • Exemple : {id} → /utilisateur/afficher-3 donne id = 3.

  • But : Permet d’avoir des URLs propres, lisibles et indépendantes des noms de fichiers réels.

name : identifiant unique de la route

  • Définition : C’est une clé unique qui identifie la route dans votre application.

  • Utilité :

    • Générer des URLs dans votre code sans les coder en dur.

    • Référencer une route de manière stable même si le path change.

On peut penser à name comme à un alias pour la route.

[controller, action] : le contrôleur et l’action associée

controller

  • Définition : Le dossier dans app/controllers où se trouvent les fichiers PHP qui gèrent cette route.

  • Exemple : utilisateur → les fichiers se trouvent dans app/controllers/utilisateur/.

action

  • Définition : Le fichier PHP correspondant à la route, sans l’extension .php.

  • Exemple : show → le fichier complet est app/controllers/utilisateur/show.php.

Rôle du couple controller/action

  • Le contrôleur contient la logique de traitement de la requête.

  • L’action correspond à la ressource exacte à exécuter pour cette route.

  • Ensemble, ils permettent à index.php (le front controller) de savoir quel fichier inclure et exécuter pour répondre à l’URL demandée.

Méthodeapp/helpers.php

Le fichier helpers sert à regrouper des fonctions destinées à simplifier l’écriture du code. Nous devons y ajouter les fonctions suivantes dans app/helpers.php.

Méthodefunction path(): string

La fonction path() permet de récupérer le chemin demandé par le navigateur et de le ramener sous une forme utilisable par le routeur.

Elle transforme l'URL du navigateur en chemin relatif à l'application, sans les paramètres GET.

1
function path(): string
2
{
3
    // Récupère le chemin demandé, sans les paramètres GET
4
    $requestUri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
5
6
    // Récupère le dossier de base de l'application
7
    $basePath = str_replace('\\', '/', dirname($_SERVER['SCRIPT_NAME']));
8
9
    // Supprime le chemin de base s'il est présent
10
    if (str_starts_with($requestUri, $basePath)) {
11
        $requestUri = substr($requestUri, strlen($basePath));
12
    }
13
14
    // Normalise le chemin en ajoutant un seul / au début
15
    return '/' . ltrim($requestUri, '/');
16
}

Méthodefunction getRoute(array $routes, string $url): ?array

La fonction getRoute sert à trouver quelle route correspond à l’URL demandée et à récupérer les informations nécessaires pour exécuter la bonne ressource.

En pratique :

  • Elle parcourt toutes les routes définies dans $routes.

  • Elle compare l’URL demandée avec le path de chaque route.

  • Si l’URL correspond :

    • Elle retourne le contrôleur à utiliser (controller).

    • Elle retourne l’action à exécuter (action).

    • Elle extrait les paramètres dynamiques de l’URL (comme {id}) pour que le contrôleur puisse les utiliser.

  • Si aucune route ne correspond, elle retourne null

1
function getRoute(array $routes, string $url): ?array
2
{
3
    foreach ($routes as $route) {
4
5
        // Récupère le chemin de la route
6
        $path = $route[0];
7
8
        // Transforme {parametre} en groupe nommé
9
        // Exemple : {slug} devient (?P<slug>[^/]+)
10
        $pattern = preg_replace(
11
            '/\{(\w+)\}/',
12
            '(?P<$1>[^/]+)',
13
            $path
14
        );
15
16
        // Ajoute les délimiteurs de l'expression régulière
17
        $pattern = '#^' . $pattern . '$#';
18
19
        // Vérifie si l'URL correspond à la route
20
        if (preg_match($pattern, $url, $matches)) {
21
22
            // Conserve uniquement les paramètres nommés
23
            $params = array_filter(
24
                $matches,
25
                'is_string',
26
                ARRAY_FILTER_USE_KEY
27
            );
28
29
            return [
30
                'controller' => $route[2][0],
31
                'action' => $route[2][1],
32
                'params' => $params
33
            ];
34
        }
35
    }
36
37
    // Aucune route trouvée
38
    return null;
39
}

Méthodefunction route(string $name, array $params = []): string

La fonction route permet de générer automatiquement l’URL correspondant à une route définie, sans avoir à l’écrire manuellement.

  • Elle prend en entrée le nom de la route (name) et éventuellement des paramètres dynamiques (par exemple id).

  • Elle retourne l’URL complète prête à être utilisée dans un lien ou un formulaire.

Exemples dans vos liens href ou dans vos header :

< ?= route('home.index') ?>

< ?= route('utilisateur.show', ['id' => 3]) ?>

header('location:' . route('utilisateur.index'));

1
function route(string $name, array $params = []): string
2
{
3
    global $routes;
4
5
    // Recherche la route à partir de son nom
6
    foreach ($routes as $route) {
7
8
        if ($route[1] !== $name) {
9
            continue;
10
        }
11
12
        // Récupère l'URL de la route
13
        $url = $route[0];
14
15
        // Remplace les paramètres de l'URL
16
        // Exemple : {slug} devient jean-dupont
17
        foreach ($params as $key => $value) {
18
            $url = str_replace('{' . $key . '}', $value, $url);
19
        }
20
21
        // Récupère le dossier de l'application
22
        // à partir du script d'entrée public/index.php
23
        $basePath = str_replace(
24
            '\\',
25
            '/',
26
            dirname($_SERVER['SCRIPT_NAME'])
27
        );
28
29
        // Assemble le chemin de base et l'URL de la route
30
        return rtrim($basePath, '/') . '/' . ltrim($url, '/');
31
    }
32
33
    // Aucune route ne correspond au nom demandé
34
    return '';
35
}

Méthodefunction getParams($key, $default=null): string|int|null

La fonction getParams permet de retourner la valeur de la clé se trouvant dans la route.

1
function getParams(string $key): ?string
2
{
3
    global $route;
4
    return $route['params'][$key] ?? null;
5
}

Méthodefunction view($name, $vars = []): void

La fonction view() permet d’inclure une vue (un fichier PHP de app/views) et de lui transmettre des variables. Elle simplifie donc l’affichage du contenu depuis un contrôleur.

Exemple dans vos contrôleurs :

return view('utilisateur.update', compact('page_title', 'page_styles', 'utilisateur'));

1
function view(string $name, array $vars = []): void
2
{
3
    extract($vars);
4
5
    // On remplace les . par des / pour obtenir le chemin du fichier
6
    $url = str_replace(".", "/", $name);
7
8
    // Inclusion du fichier de la vue s'il existe
9
    if (is_file("../app/views/$url.php")) {
10
        require "../app/views/$url.php";
11
        return;
12
    }
13
14
    // Inclusion du fichier index.php dans le dossier de la vue s'il existe
15
    if (is_file("../app/views/$url/index.php")) {
16
        require "../app/views/$url/index.php";
17
        return;
18
    }
19
20
    // Sinon, message d'erreur
21
    echo "La vue $name est introuvable.";
22
}

Méthodefunction redirect(string $routeName, array $vars = []): void

La fonction redirect() permet de rediriger l’utilisateur vers une autre page du site en utilisant le nom d’une route. Elle simplifie le code en encapsulant l’appel à header() et exit.

Exemple dans vos contrôleurs :

return redirect('utilisateur.index');

1
function redirect(string $routeName, array $vars = []): void
2
{
3
    // Génération de l'URL à partir du nom de la route
4
    $url = route($routeName, $vars);
5
    // Redirection HTTP
6
    header("Location: " . $url);
7
    exit;
8
}

Méthodepublic/index.php

Il est nécessaire de mettre à jour le Front Controller pour qu’il exploite les fonctions définies dans le fichier helpers ainsi que le système de routes.

1
<?php
2
// ==============================
3
// INCLUSION DES FONCTIONS
4
// ==============================
5
require '../app/models/model.php';
6
require '../app/helpers.php';
7
$routes = require '../app/routes.php';
8
9
// ==============================
10
// RÉCUPÉRATION DE LA ROUTE EN FONCTION DU PATH
11
// ==============================
12
13
$route = getRoute($routes, path());
14
15
// ==============================
16
// RECUPERATION DU CONTRÔLEUR ET DE L’ACTION
17
// ==============================
18
if ($route) {
19
   $controller = $route['controller'];
20
   $action = $route['action'];
21
} else {
22
   $controller = 'error';
23
   $action = 'index';
24
}
25
26
// ==============================
27
// INCLUSION DE LA RESSOURCE
28
// ==============================
29
$file = "../app/controllers/$controller/$action.php";
30
31
if (!file_exists($file)) {
32
   http_response_code(404);
33
   $file = "../app/controllers/error/index.php";
34
}
35
36
require $file;
37

Méthodecontrollers

  • Il est nécessaire de mettre à jour les Controllers afin qu’ils utilisent les fonctions définies dans le fichier helpers.

  • Tous les require vers les vues sont remplacés par la fonction view().

  • Les lignes $id = (int)($_GET['id'] ?? 0); deviennent $id = (int)getParams('id');.

  • Enfin, toutes les fonctions header et le exit sont remplacées par la fonction redirect().

Par exemple :

1
require '../app/views/utilisateur/show.php';

devient

1
return view('utilisateur.show', compact('page_title', 'page_styles', 'utilisateur'));

La fonction view() ne connaît que ce qu’on lui transmet. En PHP, une fonction possède son propre scope (espace de variables).

Les variables définies dans le contrôleur ne sont donc pas automatiquement disponibles dans la vue. Il faut les passer explicitement en paramètre.

1
header('location:index');
2
exit;

devient

1
return redirect('utilisateur.index');

Méthodeviews

Toutes les références aux liens du site dans les attributs href des vues doivent être mises à jour.

Ainsi que tous les require vers les vues sont remplacés par la fonction view().

Par exemple :

1
<li><a href='<?= asset('') ?>'>Accueil</a></li>

devient

1
<li><a href='<?= route('home.index') ?>'>Accueil</a></li>
1
<a href="utilisateur/show?id=<?= $utilisateur['id'] ?>">

devient

1
<a href="<?= route('utilisateur.show', ['id' => $utilisateur['id']]) ?>">
1
<?php require '../app/views/head.php'; ?>

devient

1
<?php view('head', compact('page_title', 'page_styles')); ?>

view étant une fonction, il ne faut pas oublier de lui transmettre les variables utiles à la vue.

1
$photoDir = '../images/photos/';

devient

1
$photoDir = 'images/photos/';

Méthode

Nous pouvons désormais vérifier le bon fonctionnement du site et constater que les URLs sont réécrites conformément à celles définies dans les routes.