Partie 21
Module
Gestion des routes dans
Overview of HTML and CSSLaravel
Dans cette partie vous allez apprendre
• Routage de base
• Paramètres de routage
• Les routes nommées
• Les requêtes HTTP
• Les réponses HTTP
Routage de base
• Le routage dans Laravel
• Le routage est un mécanisme qui permet de lier une URI (Identifiant de
Ressource Uniforme, autrement dit la partie de l’adresse qui suit le nom de
domaine) à une action.
• Toutes les routes dans Laravel sont placées dans les répertoire /routes qui
contient essentiellement les deux fichiers :
• [Link] : qui définit les itinéraires qui sont destinés au site Web.
• [Link] : qui définit les itinéraires qui sont destinés aux api.
Routage de base
• Le fichier [Link]
• Par défaut on trouve la définition de la route suivante :
<?php
use Illuminate\Support\Facades\Route;
Route::get('/',function(){
return view ("welcome");
});
• Ici une route est accessible sur le / (c’est-à-dire [Link] elle
retourne à la vue "welcome" .
• La méthode statique get() de la classe Route prend deux arguments :
• Le premier est l'URI.
• Le 2ème peut être une fonction ou un string. Dans notre cas il s'agit d'une fonction qui
retourne à la vue "welcome"
Routage de base
• Route::view
• Si l'itinéraire ne doit renvoyer qu'une vue on peut utiliser la méthode
Route::view :
<?php
use Illuminate\Support\Facades\Route;
Route::view('/', 'welcome');
• La méthode statique view() de la classe Route accepte deux arguments :
• Le premier est l'URI.
• Le 2ème est le nom de la vue qui correspond à la vue "welcome"
Routage de base
• Définir une route
• On va définir nos propres routes de la façon suivante :
<?php
use Illuminate\Support\Facades\Route;
Route::get('/contacts', function(){
return "<h1>All contacts</h>";
});
Route::get('/contacts/create', function(){
return "<h1>Add new contact</h>";
})
Routage de base
• Route avec un contrôleur
• On peut aussi spécifier des noms de route pour les actions du contrôleur.
• Pour créer un contrôleur on utilise :
php artisan make:controller UserController
• La route /users est définit de cette façon :
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\UserController;
Route::get("/users",[UserController::class,'index']);
• Le contrôleur UserController :
class UserController extends Controller
{
public function index(){
return "<h1>Hello from UserController</h1>";
}
}
Routage de base
• Les méthodes de route disponibles
• La classe Route prend en charge différentes méthodes qui répondent à
n'importe quel verbe HTTP :
Route::get($uri, $callback);
Route::post($uri, $callback);
Route::put($uri, $callback);
Route::patch($uri, $callback);
Route::delete($uri, $callback);
Route::options($uri, $callback);
• get() : utilisée pour afficher ou bien présenter des données (lecture).
• post() : utilisée pour créer ou mettre à jour les données.
• put() : utilisée pour une mise à jours complète des données.
• patch() : utilisée pour une mise à jour partielle des données.
• delete() : utilisée pour la suppression
• options() : utilisée par les clients API pour savoir à quelles méthodes HTTP une
ressource répond.
Routage de base
• Route::match et Route::any
• Parfois, vous vous pouvez enregistrer une route qui répond à plusieurs
verbes HTTP. Pour cela on utilise la méthode Route::match.
Route::match(['get','post'],'/contacts', function(){
return "<h1>All contacts</h>";
});
• Parfois, vous pouvez même enregistrer une route qui répond à tous les
verbes HTTP en utilisant la méthode Route::any :
Route::any('/contacts', function(){
return "<h1>All contacts</h>";
});
Routage de base
• La redirection
• La méthode Route::redirect permet de définir une route qui redirige vers
un autre URI :
Route::redirect('/', '/contacts');
• Par défaut, Route::redirect renvoie un code d'état [Link] pouvez
personnaliser le code d'état à l'aide du troisième paramètre facultatif :
Route::redirect('/', '/contacts',301);
Routage de base
• La liste des routes
• La commande route:list d'artisan fournit un aperçu de toutes les routes
définies dans l'application :
php artisan route:list
• On peut aussi filtrer les routes par la commande :
php artisan route:list --path=contacts
Routage de base
• Mise en cache des routes
• Lors du déploiement de votre application en production, l'utilisation du
cache de route réduira considérablement le temps nécessaire pour
enregistrer toutes les routes de l'application.
• Pour générer un cache de route, exécuter la commande :
php artisan route:cache
• Après avoir exécuté cette commande, votre fichier de routes en cache sera
chargé à chaque requête. Et si vous ajoutez de nouvelles routes, vous
devrez générer un nouveau le cache de routes.
• Pour vider le cache de route, exécuter la commande :
php artisan route:clear
Routage de base
• La route de secours
• En utilisant la méthode Route::fallback, on peut définir une route qui sera
exécutée lorsqu'aucune autre route ne correspond à la demande entrante :
Route::fallback(function(){
return "<h1>Fallback route</h1>";
});
• La route de secours doit toujours être la dernière route enregistrée dans
l'application.
Routage de base
• Groupe de routes
• Les routes peuvent être regroupées pour éviter la répétition du code et
partager des attributs de routage ente plusieurs routes.
• Tous les URI ici ont un préfixe /admin, utilisent le middleware 'admin' et
se trouvent dans l'espace de noms App\Http\Controllers\Admin :
Route::group([
'prefix' => 'admin',
'middelware' => 'admin',
'namespace' => 'admin'
], function(){
// [Link]/admin
// Uses admin middleware
// 'App\Http\Controllers\Admin\UserController'
Route::get("/users",[UserController::class,'index']);
// [Link]/admin
// Uses admin middleware
// 'App\Http\Controllers\Admin\LogController'
Route::get("/logs",[LogController::class,'index']);
});
Paramètres de routage
• Les paramètres de route
• On peut utiliser un paramètre pour une route qui accepte des éléments
variables en utilisant des accolades :
Route::get('/contacts/{id}', function($id){
return "<h1>Contact ID : $id</h1>";
});
• Définir un paramètre facultatif :
Route::get('/contacts/{id?}', function($id=null){
if(isset($id)){
return "<h1>Contact ID : $id</h1>";
}
return "<h1>All contacts</h1>";
});
Paramètres de routage
• Définir plusieurs paramètres
• On peut définir autant de paramètres de route :
Route::get("/posts/{post}/comments/{comment}", function($pId, $cId){
return "
<h1>Post ID : $pId </h1>
<h2>Comment ID : $cId </h2>
";
});
Paramètres de routage
• Injection de dépendance : la fonction request()
• La fonction request() permet de récupérer la valeur d'un paramètre à partir
de l'url de la forme url?parm=val
Route::get('/store',function(){
$filtre = request('style');
return "This page is viewing
<span style='color:red'>$filtre</span>";
});
Paramètres de routage
• Injection de dépendance : la classe Request
• Un objet de la classe Illuminate\Http\Request permet obtenir une
instance de la requête HTTP actuelle via l'injection de dépendances :
use Illuminate\Http\Request;
Route::get('/store',function(Request $request){
return "<h2> <p>Style : $request->style </p>
<p>Age : $request->age </p></h2>";
});
Paramètres de routage
• Paramètre et injection de dépendance
• Dans ce cas il faut lister les paramètres de route après les dépendances :
use Illuminate\Http\Request;
Route::get('/store/{id}',function(Request $request, $id){
return "<h2> <p>ID : $id </p>
<p>Style : $request->style </p>
<p>Age : $request->age </p></h2>";
});
Les routes nommées
• Nommer une route
• Vous pouvez spécifier un nom pour une route en enchaînant la méthode
name sur la définition de route.
• Voici un exemple d'une route nommée qui utiliser une fonction :
Route::get('user/profile', function(){
return "<h2>Named Route</h2>";
})->name('profile');
• Voici un exemple d'une route nommée qui utiliser une contrôleur :
Route::get('user/profile', [UserProfileController::class,'show']
)->name('profile');
Les routes nommées
• Génération d'URL vers des routes nommées
• Une fois que vous avez attribué un nom à une route donnée, vous pouvez
utiliser le nom de la route lors de la génération d'URL ou une redirection
via la fonction route :
Route::get('/link',function(){
$url = route('profile');
return "<a href=$url>Go to </a>";
});
Route::get('/root',function(){
return redirect()->route('profile');
});
Les requêtes HTTP
• Introduction
• La classe Illuminate\Http\Request de Laravel fournit un moyen orienté
objet pour interagir avec la requête HTTP.
• Pour obtenir une instance de la requête HTTP actuelle via l'injection de
dépendances, il suffit d'indiquer un objet $request de la classe Request
sur la méthode de fermeture de la route ou du contrôleur :
use Illuminate\Http\Request;
Route::get('/', function (Request $request) {
// ...
});
use Illuminate\Http\Request;
class UserController extends Controller
{
public function store(Request $request): RedirectResponse
{
$name = $request->input('name');
// Store the user...
return redirect('/users');
}
}
Les requêtes HTTP
• Récupérer le chemin de la requête
• La méthode path() de l'instance $request renvoie les informations de
chemin de la requête.
$uri = $request->path();
• Si par exemple la requête entrante est [Link]
alors la méthode path() renvoie : foo/bar
Les requêtes HTTP
• Inspecter le chemin de la requête
• La méthode is() de l'isntance $request permet de vérifier si le chemin de
la requête entrante correspond à un modèle donné.
• On peut utiliser le caractère * comme caractère générique lors de
l'utilisation de cette méthode :
if ($request->is('admin/*')) {
// ...
}
• La méthode routeIs(), permet de déterminer si la requête entrante
correspond à une route nommée :
if ($request->routeIs('admin.*')) {
// ...
}
Les requêtes HTTP
• Récupérer l'URL de la requête
• Pour récupérer l'URL complète de la requête entrante on peut utiliser les
deux méthodes suivantes de l'instance $request :
• url() : revoie l'URL sans la chaîne de requête (without the query string)
• fullUrl() : revoie l'URL incluant la chaîne de requête.
• Voici un exemple :
Route::get('/admin/route',function(Request $request){
$url = $request->url();
$fullUrl = $request->fullUrl();
return "
<p>URL : $url</p>
<p>FULL URL : $fullUrl</p>";
});
Les requêtes HTTP
• Récupérer l'hôte de requête (Request Host)
• On peut récupérer l'hôte de la requête entrante via les méthodes host(),
httpHost() et schemeAndHttpHost.
• Voici un exemple :
Route::get('/admin/route',function(Request $request){
$host = $request->host();
$httpHost = $request->httpHost();
$schemeAndHttpHost =$request->schemeAndHttpHost();
return "
<p>Host : $host</p>
<p>HttpHost : $httpHost</p>
<p>SchemeAndHttpHost : $schemeAndHttpHost</p>";
});
Les requêtes HTTP
• Récupérer la méthode de le requête (Request Method)
• La méthode method() renvoie le verbe HTTP pour la requête.
• On peut aussi utiliser la méthode isMethod() pour vérifier que le verbe
HTTP correspond à une chaîne donnée :
$method = $request->method();
if ($request->isMethod('post')) {
// ...
}
Les requêtes HTTP
• Récupérer toutes les données d'entrée de la requête
• On peut récupérer toutes les données d'entrée de la requête sous forme
d'un tableau à l'aide de la méthode all() :
Route::get('/posts',function(Request $request){
$inputs = $request->all();
return $inputs;
});
• Dans le cas des entées dans un formulaire :
Route::post('/form', function(Request $request){
return $request->all();
})->name('profile');
Les requêtes HTTP
• Récupérer la valeur entée par l'utilisateur
• La méthode input() peut être utilisée pour récupérer l'entrée de
l'utilisateur dans un formulaire.
$name = $request->input('name');
• On peut passer une valeur par défaut comme deuxième argument à la
méthode input(). Cette valeur sera renvoyée si la valeur d'entrée
demandée n'est pas présente dans la requête :
$name = $request->input('name', 'Sally');
• La méthode input() récupère les valeurs d'entrée de l'utilisateur dans un
formulaire et aussi les valeurs entrées dans la chaîne de requête. Il existe
aussi la méthode query() qui récupère uniquement les valeurs de la
chaîne de requête :
Route::get('/posts',function(Request $request){
$style = $request->query('style');
$age = $request->query('age');
return "$style AND $age ";
});
Les requêtes HTTP
• Récupérer les valeurs entées via les propriétés dynamiques
• On peut également accéder aux entrées de l'utilisateur à l'aide des
propriétés dynamiques sur l'instance $request.
• Par exemple, si l'un des formulaires de votre application contient un
champ name, vous pouvez accéder à la valeur du champ à l'aide de la
méthode input('name') ou bien à l'aide de la propriété dynamique name
de cette façon :
$name = $request->input('name');
$name = $request->name;
Les requêtes HTTP
• Déterminer si une entrée est présente
• On peut utiliser la méthode has() pour déterminer si une valeur est
présente sur la requête. La méthode has() renvoie true si la valeur est
présente sur la requête :
if ($request->has('name')) {
// ...
}
• Lorsqu'on lui donne un tableau, la méthode has() déterminera si toutes
les valeurs spécifiées sont présentes :
if ($request->has(['name', 'email'])) {
// ...
}
• La méthode hasAny() renvoie true si l'une des valeurs spécifiées est
présente.
if ($request->hasAny(['name', 'email'])) {
// ...
}
• La méthode has('name') retourne true même si name est vide, et pour
s'assurer qu'elle n'est pas vide on utilise la méthode filled('name').
Les réponses HTTP
• La réponse de base
• Toutes les routes et les contrôleurs doivent renvoyer une réponse au
navigateur de l'utilisateur.
• Laravel propose plusieurs façons pour renvoyer les réponses.
• La réponse la plus basique consiste à renvoyer une chaîne à partir d'une
route ou d'un contrôleur et le framework convertira automatiquement la
chaîne en une réponse HTTP complète :
Route::get('/', function () {
return 'Hello World';
});
• On peut également renvoyer des tableaux, et le framework convertira
automatiquement le tableau en une réponse JSON :
Route::get('/', function () {
$users = [
['userid' => 1, 'name' => 'Alex'],
['userid' => 2, 'name' => 'Jane'],
];
return $users;
});
Les réponses HTTP
• La réponse objet
• Dans Laravel, une réponse view peut être renvoyée aussi :
Route::get('/form', function(){
return view("welcome");
});
• On peut aussi renvoyer des modèles directement à partir des routes et des
contrôleurs :
use App\Models\User;
Route::get('/user/{user}', function (User $user) {
return $user;
});
Les réponses HTTP
• Rediriger la réponse
• Une réponse de redirection est une réponse HTTP qui redirige le client
vers une URL différente.
• Les réponses de redirection peuvent être créées à l'aide de la fonction
d'assistance globale redirect() :
Route::get('/dashboard', function () {
return redirect('home/dashboard');
});
• Parfois, on veut rediriger l'utilisateur vers son emplacement précédent à
l'aide de de la fonction d'assistance globale back() :
Route::post('/user/profile', function () {
// Validate the request...
return back()->withInput();
// return redirect()->back()->withInput();
});
Les réponses HTTP
• Rediriger la réponse vers une route nommée
• Lorsque vous appelez la fonction d'assistance globale redirect() sans
paramètre, une instance de la classe Illuminate\Routing\Redirector est
retournée, qui va permettre d'appeler n'importe quelle méthode sur
l'instance. Parmi ces méthodes on trouve la méthode route() qui permet
de générer une RedirectResponse vers une route nommée :
Route::post('/user/profile', function () {
// ...
return redirect()->route('login');
// return redirect(route('login'));
});
• Si la route nommée a des paramètres, on peut les passer comme
deuxième argument à la méthode route() :
// For a route with the following URI: /profile/{id}
return redirect()->route('profile', ['id' => 1]);
Les réponses HTTP
• Rediriger la réponse vers une action d'un contrôleur
• On peut également générer des redirections vers les actions du contrôleur.
• Pour ce faire, transmettez le contrôleur et le nom de l'action à la méthode
action() :
use App\Http\Controllers\UserController;
return redirect()->action([UserController::class, 'index']);
• Si la route du contrôleur nécessite des paramètres, on peut les passer
comme deuxième argument à la méthode action() :
return redirect()->action(
[UserController::class, 'profile'], ['id' => 1]
);
Les réponses HTTP
• Rediriger la réponse vers un domaine externe
• Parfois, on veut rediriger l'utilisateur vers un domaine en dehors de notre
application.
• On peut le faire à l'aide de la méthode away() :
return redirect()->away('[Link]
// return redirect('[Link]
