Guide de Cours Et TPs

Guide de cours et TPs
L’essentiel de Laravel
Laravel ‫المختصر المفيد في لغة‬

Préparé par :
M. Hamid Mask
1 / 105
Très bon cours :
https://apcpedagogie.com/cours-et-tutoriels/les_cours/cours-de-programmation/laravel/
Laravel?
I. Installation des outils pour Laravel
1. Installation de Composer
Pour installer Composer, il suffit de télécharger un installeur :
https://getcomposer.org/download/
Et téléchargez le fichier : Composer-Setup.exe.
Vérifiez lors de l'installation que le chemin par défaut vers PHP est bien
C:\PHP\php.exe, car Composer est un fichier PHP et a besoin d’être exécuté.
2. Vérifications
Pour vérifier que tout fonctionne, exécuter composer sur la ligne de commande
comme suit :
II. Créer un nouveau projet Laravel

1. Utiliser l’installeur de Laravel
 Installer Laravel dans votre ordinateur :
Ouvrez votre terminal (invite de commande) et tapez la ligne suivante :
composer global require laravel/installer
2 / 105
2. Créer notre premier projet laravel (tp1_laravel) – Méthode 1 :
Changer de répertoire de travail en plaçant le terminal dans le repertoire www

(Wampserver) ou htdocs (Xampserver) :
cd c:\wamp64\www\TPs Laravel
Taper la commande :
Laravel new tp1_laravel
3. Créer un nouveau projet Laravel avec Composer – Méthode 2:
Créer un deuxième projet à la racine du serveur nommé tp2_laravel avec la

commande suivante :
En se plaçant dans le dossier : c:\wamp64\www\TPs Laravel\ , taper la
commande suivante :
composer create-project laravel/laravel tp2_laravel
Ici nous avons demandé à composer de créer une installation Laravel dans le dossier
«tp2_laravel». Cette commande installera automatiquement la dernière version stable de
Laravel.
Finalement :
3 / 105
III. Architecture d’un projet Laravel
IV. Laravel Artisan

1. Qu'est ce que Laravel Artisan?
² est une Interface en Ligne de Commande (CLI) qui va vous permettre de
gérer votre application en lançant des commandes via le terminal (effacer le
cache de l’application, gérer des modèles, des contrôleurs, des routes…)
 Laravel Artisan: commandes utiles

1) Afficher la liste des commandes artisan :
php artisan list
4 / 105
2) Pour afficher un écran d'aide, faites précéder le nom de la commande de
help :
php artisan help migrate
3) Pour créer un modèle
php artisan make:model NomDuModel
4) Vérifier la version de Laravel installée
php artisan -version
5) lancer le serveur , lancer le projet Laravel
php artisan serve

6) voir toutes les routes de votre application
artisan route:list
7) Exécuter toutes les migrations:

php artisan migrate
8) faire un retour en arrière pour la dernière migration
php artisan migrate : rollback
V. Lancer le projet Laravel

1- Placez le terminal dans le dossier racine de votre projet et taper les
commandes :
php artisan key:generate
ensuite :
php artisan serve
2- Ouvrez le navigateur et tapez http://localhost/:8000, vous obtiendrez le

résultat suivant :
5 / 105
VI. Application MVC avec Laravel :
Les Modèles (Models)
 Ce que nous appelons un Modèle est en réalité un fichier PHP qui ne
fait que gérer les échanges avec la base de données. Lorsque nous
avons besoin de lire ou écrire dans la base de données, nous faisons
appel au Modèle.
 Le modèle est la couche représentant les données. On l’appellera
parfois logique métier.
 Le modèle consiste en une série de classes. Si les données sont tirées
de la BD, chacune des classes représentera une table.
 Parmi les fonctionnalités codées dans le modèle, on retrouve les
relations entre les tables, les accesseurs et modificateurs, les champs
calculés, etc.
Les Vues (Views)

 La vue est constituée de balises HTML qui représentent ce qui sera
affiché à l’écran, c’est une interface utilisateur.
 En plus des balises HTML, la vue peut utiliser des directives et
instructions prévues par le moteur d’affichage afin d’effectuer
différentes opérations, comme par exemple tester une condition ou
encore boucler dans les données fournies par le modèle.
6 / 105
 La vue pourra faire appel à des ressources externes, comme des
feuilles de style, des fichiers JavaScript, des images, etc.
 Sous Laravel, le moteur d’affichage s’appelle Blade.
Les Contrôleurs (Controllers)

 Véritable tour de contrôle de notre application, le contrôleur a pour
fonction de faire l’interface entre les modèles et les vues. Il est chargé
de demander les données par l’intermédiaire des modèles, de traiter
ces données et de les transmettre aux vues, prêtes à être utilisées.
Le routing
 Bien qu’indépendant de l’architecture MVC, le routing fait partie
intégrante de tous les Frameworks PHP.
 Dans une architecture classique, nous pointons vers des fichiers :
 http://monsite.fr/index.php
 http://monsite.fr/inscription.php
 http://monsite.fr/login.php
 …
Exemples
Dans une architecture MVC, nous allons pointer vers des dossiers virtuels
appelés routes
 http://monsite.fr/user/inscription
 http://monsite.fr/user/login
 http://monsite.fr/blog/article
…
Cette architecture offre de nombreux avantages :

 Protection des fichiers, ceux-ci n’étant plus affichés par le
navigateur
 Des URLs plus simples à mémoriser pour les utilisateurs
 Amélioration du référencement si les routes contiennent des
mots-clés contenus dans la page correspondante
VII. Application
 Pour comprendre comment Laravel intègre la logique MVC, créons un
exemple de projet Laravel qui affiche la liste des apprenants d’une école de
formation.
 Pour créer un nouveau projet, exécutez la commande ci-dessous dans votre
terminal :
7 / 105
laravel new gestionApprenant
Toutes les commandes artisanales d’un projet Laravel doivent être

exécutées à la racine du projet Laravel, vous devez donc revenir à la
racine avec la commande cd y aller avant d’exécuter la commande. Pour
arrêter le serveur, appuyez sur ctrl + c sur votre clavier pour Windows
Modèles:
 Créer notre modèle d’apprenant.
 Créons notre premier modèle, M en MVC, pour notre application. Comme
nous l’avons dit, le modèle s’interface généralement avec un stockage de
données comme une base de données MySQL par exemple.
 Dans Laravel, le modèle est généralement une classe dont les propriétés
correspondent aux colonnes de la base de données.
 Dans notre base de données, un produit aura les propriétés suivantes:
 Nom ( firstname) – Nom de l’apprenant.
 Prénom ( lastname) – Prénom de l’apprenant.
 Date Naissance ( dteNaissance) – Date Naissance de l’apprenant.
 Adresse ( adress) – Adresse de l’apprenant.
 Pour créer un modèle dans Laravel, exécutez la commande dans votre

terminal:
php artisan make : model mdlApprenant
 Lorsque vous exécutez cette commande, Laravel créera un
fichier mdlApprenant.php dans le répertoire app. Ce sera une classe
PHP avec le nom mdlApprenant et ce sera le modèle de notre table
apprenants dans la base de données.
Lien très Interressant :

How Laravel implements MVC and how to use it effectively :
https://pusher.com/blog/laravel-mvc-use/#controllers-creating-our-controller
VIII. Créer des Routes sous Laravel
Routage sous Laravel
1. Qu’est-ce que le routage sous Laravel
8 / 105
 Laravel fournit un système de routes simple. Déclarer une route permet
de lier une URI (identifiant de ressource uniforme, autrement dit la
partie de l’adresse qui suit le nom de domaine) à un code à exécuter.
 Toutes les routes Laravel sont définies dans le fichier situé sous
/routes/web.php , qui est automatiquement chargé par le framework
2. Présentation
 Lorsque Laravel est installé et configuré, vous aurez tous les fichiers
dont vous avez besoin dans votre dossier pour commencer un
projet Laravel.
 Lorsqu’on affiche une page Web Laravel dans le navigateur, l’URL ne
se terminera pas par le nom d’un fichier (.html ou .php). Plutôt, il
s’agira d’une suite de mots ressemblant à des dossiers et sous-
dossiers, comme par exemple http://127.0.0.1:8000/inscription.
 Toutes les routes d’application sont enregistrées dans le
fichier web.php .
 Par défaut, Laravel s’installe avec un dossier de routes, pour gérer

divers besoins des itinéraires, dans son répertoire racine, ce dossier
contient quatre fichiers :
• api.php (utilisé pour gérer les routes de l’API)
• channels.php
• console.php
• web.php (gère les routes normales)
 Pour créer une route, il faut ainsi appeler la classe Route avec la
méthode HTTP souhaitée (get par exemple).
Indiquez à cette méthode l’URI concernée et le retour à afficher pour le
visiteur comme dans l’exemple ci-dessous.
 Fichier routes/web.php :
Route::get('accueil', function () {
return "Bienvenue sur le site !";
});
9 / 105
 Dans ce cours, nous nous concentrerons principalement sur
le web.php, car c’est là que tous nos itinéraires vont vivre.
 Le routage dans Laravel comprend trois catégories :
 Routage de base
 Routes nommés
 Paramètres de Route
3. Routage de base
 Route basique
 Une route Laravel très basique est simplement exprimée comme
suit :
Route::get('/', function () {
return "Welcome to Laravel Site.";
});
 Ici, « Route » est une classe qui a une méthode statique « get »
qui renvoie une méthode « view » qui présente une page Web.
 Lorsqu’un utilisateur visite la page d’accueil, il est redirigé vers la

page « Bienvenue » page. Cet « welcome » page est en fait un
fichier PHP : « welcome.blade.php » .
 Il a été stocké par défaut dans le dossier « vues » pendant

l’installation de Laravel. Lorsque nous discutons du concept du
moteur de modèle « vue » et « lame », vous comprendrez
parfaitement ce qui se passe dans la couche de présentation.
 Plusieurs routes et paramètre de route comme suit :
10 / 105
 À l’installation Laravel a une seule route qui correspond à l’URL
de base composée uniquement du nom de domaine. Voyons
maintenant comment créer d’autres routes.
 Imaginons que nous ayons trois pages qui doivent être affichées
avec ces URL :
http://monsite.fr/1
http://monsite.fr/2
http://monsite.fr/3
Route::get('1', function() { return 'Je suis la page 1 !'; });

 afficher des pages « view »
 Si vous ouvrez le dossier Route, vous verrez quatre fichiers :
 api.php,
 channels.php,
 console.php
 web.php
 C’est ce fichier web.php que nous voulons examiner.

 Les routes utilisées sont définies dans le fichier routes\web.php.
 Par défaut, nous avons accès à une route pour la page d’accueil qui
est écrite sous cette forme :
11 / 105
return view('welcome');
});
Comme Laravel est explicite vous pouvez déjà deviner à quoi sert ce code :
 Route : on utilise le routeur, appel statique de la classe qui gère le

système de route ;
 get : on regarde si la requête a la méthode « get » ;
 ‘/‘ : on regarde si l’URL comporte uniquement le nom de domaine ;
 ‘return‘: retourne une vue (view) à partir du fichier
welcome.blade.php dans le dossier resources\views .
 Création de nouvelles routes

Il est possible et même nécessaire d’ajouter d’autres routes pour diriger les
demandes vers la bonne méthode d’un contrôleur ou encore, comme c’est le cas
dans le code précédent, vers la bonne vue.
});
Route::get('/inscription', function () {
return view('inscription');
});
La vue inscription.blade.php doit être créé :
12 / 105
 Verbes de route
 Vous avez peut-être remarqué que nous utilisons Route :: get dans
nos définitions d’itinéraire.
 Cela signifie nous disons à Laravel de ne faire correspondre ces

routes que lorsque la requête HTTP utilise la méthode GET.
 Mais que se passe-t-il s’il s’agit d’un formulaire POST, ou peut-être

d’un JavaScript envoyant PUT ou DELETE.
 Il existe quelques autres options pour les méthodes permettant

d’appeler une définition d’itinéraire, comme illustré ci-dessous :
return 'Hello, World!';
});
Route::post('/', function () {});

Route::put('/', function () {});
Route::delete('/', function () {});
Route::any('/', function () {});
13 / 105
Route::match(['get', 'post'], '/', function () {});
 GET: Ceci est principalement utilisé pour récupérer les données du
serveur, sans modifier les données et les renvoyer à l’utilisateur.
 POST: Cela nous permet de créer de nouvelles ressources ou données
sur le serveur, bien que cela puisse être utilisé uniquement pour envoyer
des données, pour un traitement ultérieur (cela pourrait être la validation
des données, comme dans le processus de connexion). Il est considéré
comme plus sûr que GET pour l’envoi de données sensibles.
 PUT: Put fonctionne comme le POST dans le sens où il vous permet
d’envoyer des données au serveur, généralement pour mettre à jour une
ressource existante au lieu de la créer. Vous le mettez essentiellement.
 DELETE: Delete permet de supprimer une ressouce existante dans le

serveur.
4. Routes nommées
 Il est parfois utile de nommer une route, par exemple pour générer
une URL ou pour effectuer une redirection.
 L’avantage d’utiliser une route nommée est que si nous changeons
l’URL d’une route à l’avenir, nous n’aurons pas besoin de changer l’URL ou
les redirections pointant vers cette route si nous utilisons une route nommée.
 Les routes nommées sont créées en utilisant as clé de tableau ou en utilisant la
méthode name
 La syntaxe (avec as)
Route::get('uri', [
'as' => 'nomRoute',
'uses' => 'NomControleur@methode'
]);
Exemple:
Route::get('login', ['as' => 'home', 'uses'
=> 'HomeController@index']);
 La syntaxe (méthode name)
Route::get('/home', 'HomeController@index')->name('home');
14 / 105
 Générer une URL à l’aide d’une route nommée
 Pour générer une URL en utilisant le nom de la route :
$url = route('home');
<a href="{{ route('home') }}">
 Si vous utilisez le nom de la route pour la redirection :
$redirect = Redirect::route('home');
5. Les paramètres des routes
 Partant de l’exemple précédent on peut se poser une question : est-il

vraiment indispensable de créer trois routes alors que la seule
différence tient à peu de choses : une valeur qui change ?
 On peut utiliser un paramètre pour une route qui accepte des éléments
variables en utilisant des accolades. L’exemple devient alors :
Route::get('{n}', function($n) {
return 'Je suis la page ' . $n . ' !';
});
 Les paramètres des routes sont toujours entre crochets {} et doivent

être composés de caractères alphabétiques. Ne peut pas contenir le
caractère « - » , peut utiliser le caractère « _ » en substitution des
caractères « - » .
 Les paramètres de routage sont injectés dans le contrôleur ou la

fonction de rappel en fonction de leur ordre, plutôt que par les
paramètres de la fonction de rappel ou du contrôleur.
15 / 105
 Paramètres obligatoires
 Par exemple, si vous souhaitez capturer l’ID utilisateur dans l’URL
lorsque vous souhaitez obtenir les détails de l’utilisateur, vous pouvez
vous référer aux pratiques suivantes :
Route::get('user/{id}', function ($id) {

return 'User '.$id;
});
 Plusieurs paramètres de routage peuvent également être capturés, par

exemple :
Route::get('posts/{post}/comments/{comment}', function
($postId, $commentId) {
return 'Post : '.$postId.' - Comment : '.$commentId;
});
 Paramètres facultatifs
 Parfois, vous devez spécifier des paramètres de routage, mais les
paramètres ne sont pas obligatoires. Le caractère « ? » est marqué
après le nom du paramètre pour garantir que la valeur par défaut est
donnée à la variable correspondante de l’itinéraire.
Route::get('user/{name?}', function ($name = null) {

return $name;
});
Route::get('user/{name?}', function ($name = 'Tom') {

return $name;
});
16 / 105
6. Routage avec des méthodes de contrôleur
 Vous pouvez créer une route avec une méthode de contrôleur d’appel, vous
pouvez donc simplement créer une méthode de contrôleur et appeler cette
méthode avec votre route comme ci-dessous :
Route :: get ( 'ma-route' , 'TestController@index' );
 Prenons un exemple de routes laravel avec des contrôleurs. Si vous passez le

nom de la méthode du contrôleur dans route et que l’utilisateur atteindra la
route, la méthode du contrôleur défini sera exécutée pour effectuer les actions.
Route::get('/home', 'HomeController@home');
 Dans l’exemple de code ci-dessus, la route commence par la Route :: façade et

la méthode utilisera la route est get.
7. Applications
 Exercice 01
1- Créer la liste des routes pour répondre aux URL suivants :
 http://localhost/laravel/public/
 http://localhost/laravel/public/login
 http://localhost/laravel/public/page/1
Route::get('/', function()
{
return 'accueil';
});
Route::get('login', function()
{
return 'login';
17 / 105
});
Route::get('page/1', function()
{
return 'page1';
});
2- Créer un nouveau projet Laravel

3- Ajouter une route /test
4- Ajouter un paramètre qui sera affiché : /test/param
5- Utiliser une vue pour cette route
6- Lister les routes avec la commande artisan
IX. Utiliser les vues

1. Créer une vue sous Laravel
 Présentation
 Les vues dans Laravel contiennent une logique qui détermine comment
présenter le résultat final de l’application Web aux utilisateurs.
La sortie est souvent la sortie HTML qui, après chaque réponse, revient
aux utilisateurs. Le répertoire resources/views contient ces vues par
défaut dans Laravel.
 Sous Laravel, pour afficher correctement une page Web dans le
navigateur, il faut utiliser une vue. C’est la vue qui est en charge de
générer le code HTML.
 Les vues utilisent, en plus des balises HTML, des directives et
instructions que le moteur d’affichage Blade met à leur disposition.
 Créer une première vue
 Vous pouvez créer une vue en plaçant un fichier avec l’extension

.blade.php dans les resources/views de votre application.
 L’extension .blade.php informe le framework que le fichier contient un
modèle Blade.
Les bonnes pratiques veulent qu’on crée un sous-dossier pour les vues de
chacun des contrôleurs. Le nom du sous-dossier correspondra à la première
partie du nom du contrôleur, tout en minuscules (ex : pour les vues utilisées
par ApprenantsController : resources\views\apprenants).
 Étapes de création
18 / 105
 D’abord, créez un dossier nommé apprenants
sous ressources\views.
 Dans ce dossier, créez le fichier index.blade.php et copiez-y le
code suivant : CRÉER UNE VUE SOUS LARAVEL
 Ajoutez la ligne suivante dans le fichier routes/web.php pour définir
l’itinéraire pour la vue ci-dessus.
Route::get('/apprenants/index',function(){
return view('apprenants/index');
});
Visitez l’URL suivante pour voir la sortie de la vue :

http://localhost:8000/apprenants/index
La sortie apparaîtra sera :
2. Utiliser des variables sous Laravel
Voir le site
 Menu
Exemple 1 :
Web.php
Route::get('/',function(){
return "<h1>Home Page</h1>";
});
Route::get('/about',function(){
return "<h1>About Page</h1>";
})->name('about');
Route::get('/contact',function(){
return "<h1>Contact Page</h1>";
});
19 / 105
Exemple 2 :
welcom.blade.php
<h1>Home Page</h1>
about.blade.php
<h1>About Page</h1>
contact.blade.php
<h1>Contact Page</h1>
Web.php
});
return view('about');
})->name('about');
return view('contact');
});
Exemple 3 :
welcom.blade.php
<html>
<head>
20 / 105
<title>Home</title>
<style>
nav a {
padding: 0.5rem;
}
</style>
</head>
<body>
<nav>
<a href="/">Home</a>
<a href="{{route('about')}}">About</a>
<a href="/contact">Contact</a>
</nav>
<h1>Home Page</h1>
</body>
</html>
about.blade.php
<nav>
</nav>
<h1>About Page</h1>
contact.blade.php
<nav>
</nav>
Web.php
<?php
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\MenuController;
});
21 / 105
})->name('about');
});
X. Les Controllers laravel

1. Créer et utiliser un controleur Laravel
 Qu’est-ce qu’un contrôleur ?
 Dans le modèle MVC (Modèle-Vue-Contrôleur), le contrôleur contient la logique
concernant les actions effectuées par l’utilisateur. En pratique, dans une
application Laravel, l’utilisation de contrôleurs permet de libérer les routes du code
qu’elles contiennent dans leurs fonctions de rappel.
 Un controller est une classe qui va contenir différentes méthodes. Chaque méthode
correspondant généralement à une opération (URL) de votre application.
 Un contrôleur est matérialisé par une classe et chacune de ses méthodes représente
une action. Une action correspond généralement à une route.
 Rôle d’un contrôleur
22 / 105
 La tâche d’un contrôleur est de réceptionner une requête (qui a déjà été
sélectionnée par une route) et de définir la réponse appropriée, rien de
moins et rien de plus. Voici une illustration du processus :
 Les contrôleurs sont destinés à regrouper la logique de traitement des

demandes associée dans une seule classe.
 Dans votre projet Laravel, ils sont stockés dans le
répertoire app/Http/Controllers.
 La forme complète de MVC est Model View Controller, qui sert à diriger
le trafic entre les vues et les modèles.
 Créer un contrôleur sous Laravel
 Pour créer un contrôleur à partir de la fenêtre du terminal, ouvrez le

terminal et changez le répertoire vers votre dossier racine laravel :
C:\wamp64\www\TPs laravel> cd tp1_laravel
C:\wamp64\www\TPs laravel\tp1_laravel>
 Pour créer un contrôleur, vous pouvez exécuter l’une des commandes

suivantes :
23 / 105
a) Créer un simple contrôleur vierge
 Taper la commande suivante :
php artisan make:controller ClientController
ClientController.php
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class ClientController extends Controller

{
//
}
Par convention, les contrôleurs sont en notation Camel Case et terminent

tous avec le mot Controller. Cela permet de les différencier des services
et des modèles auxquels ils font référence.
 Nous allons ensuite créer une nouvelle méthode à notre Class

ClientController que l’on nommera « clients ».
<?php
24 / 105

{
public function clients() {
return view('/clients/index');
}
}
 Maintenant nous devons faire le lien entre notre fichier web.php et

notre Controller. Nous devons donc changer notre deuxième
paramètre.
Route::get('/clients/index',
'App\Http\Controllers\ClientController@clients');
Par défaut, Laravel va chercher le contrôleur dans app\Http\Controllers. Nous

spécifions également après le @, que la fonction à appeler est clients().
Pour completer l’exemple, nous allons créer un dossier clients dans resources\views.
Ensuite créer la vue index.blade.php dans le dossier clients :
index.blade.php
Liste des clients
Taper l’URL suivante pour voir la sortie de la vue :

25 / 105
http://localhost:8000/clients/index
La sortie apparaîtra sera :
b) Créer un contrôleur complet avec les méthodes CRUD

 Taper la commande suivante :
php artisan make:controller ClientController --resource
<?php

{
/**
* Display a listing of the resource.
*
* @return \Illuminate\Http\Response
*/
public function index()
{
//
}
/**
* Show the form for creating a new resource.
*
*/
26 / 105
public function create()
{
//
}
/**
* Store a newly created resource in storage.
*
* @param \Illuminate\Http\Request $request
*/
public function store(Request $request)
{
//
}
/**
* Display the specified resource.
*
* @param int $id
*/
public function show($id)
{
//
}
/**
* Show the form for editing the specified resource.
*
* @param int $id
*/
public function edit($id)
{
//
}
/**
* Update the specified resource in storage.
*
27 / 105
* @param \Illuminate\Http\Request $request
* @param int $id
*/
public function update(Request $request, $id)
{
//
}
/**
* Remove the specified resource from storage.
*
* @param int $id
*/
public function destroy($id)
{
//
}
}
 Structure d’un contrôleur Laravel
Un contrôleur est une classe qui étend la classe de base Controller et dont
chaque méthode publique représente généralement une action qui
correspond à une route.
Fichier app/Http/Controllers/clients/ClientController.php
<?php

{
public function clients() {
return view('/clients/index');
}
28 / 105
public function show($id){
return view('clients.show', [
'client' => Product::find($id)
]);
}
}
 Une méthode d’un contrôleur retourne une réponse, exactement comme

dans les fonctions de rappels à propos des routes.
 Dans l’exemple précédent, les méthodes clients et show retournent une
réponse sous la forme d’une vue , mais il aurait aussi bien pu s’agir de
chaîne de caractères ou d’un objet JSON.
 Liaison avec les routes

a) Liaison avec les routes
La figure suivante illustre une visualisation de la liaison entre la route et le
contrôleur :
 On voit qu’au niveau de la route il suffit de désigner le nom du contrôleur

et le nom de la méthode séparés par @.
 La syntaxe à utiliser est NomDuController@action sous forme d’une
chaîne de caractères.
Web.php
Route::get('/clients','ClientController@clients');
Route::get('/clients/{id}','ClientController@show');
29 / 105
b) Route nommée
 De la même manière que nous pouvons nommer une route classique
on peut aussi donner un nom à une route qui pointe une méthode de
contrôleur :
Route::get('/', 'WelcomeController@index')->name('home');
 Si on utilise Artisan pour lister les routes : php artisan route:list

 On voit bien que l’action est faite par le contrôleur avec précision de la
méthode à utiliser. On trouve aussi le nom de la route.
 Déplacer le code des fonctions de rappel des routes

 Les routes sont généralement surchargées de code pour traiter les
actions dans leurs fonctions de rappel.
 L’objectif est de les libérer de ce code pour obtenir un fichier de routes
propre qui fait simplement le lien entre les URI de l’application et les
actions à effectuer pour chacune de ces URI.
 Le fichier des routes routes/web.php est ainsi allégé, et devient un
index des différentes URI avec leurs actions associées.
 Exemple de fichier de routes sans fonction de rappel
Route::get('videos', 'VideoController@index');
Route::get('videos/creer', 'VideoController@create');
Route::post('videos/creer', 'VideoController@store');
Route::get('videos/{id}', 'VideoController@show');
I. Create pages and navigation

Pour créer le controleur MenuController Dans le dossier du projet
C:\wamp64\www\TPs laravel\tp1_laravel> tapez :
php artisan make:controller MenuController
MenuController.php
<?php
30 / 105
class MenuController extends Controller

{
public function index () {
return "<h1>Home Page</h1>";
}
public function about () {

return "<h1>About Page</h1>";
}
public function contact () {

return "<h1>Contact Page</h1>";
}
Web.php
<?php
Route::get('/',[MenuController::class, 'index']);
Route::get('/about',[MenuController::class, 'about']);
Route::get('/contact',[MenuController::class, 'contact']);
MenuController.php
<?php
31 / 105

{
}

}

}
}
about.blade.php
<h1>About Page</h1>
contact.blade.php
Menu :
Web.php (avec routes nommées)

<?php
Route::get('/',[MenuController::class,'index'])->name('home');
Route::get('/about',[MenuController::class,'about'])->name('about');
Route::get('/contact',[MenuController::class,'contact'])
->name('contact');
32 / 105
welcome.blade.php
<!DOCTYPE html>
<html lang="{{ str_replace('_', '-', app()->getLocale())
}}">
<head>
<meta charset="utf-8">
<title>Laravel</title>
<style>
nav a {
padding: 0.5rem;
}
</style>
</head>
<body>
<div>
<nav>
</nav>
<h1>Home Page</h1>
</div>
</body>
</html>
about.blade.php
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width,
initial-scale=1.0">
<title>About</title>
<style>
nav a {
padding: 0.5rem;
}
</style>
</head>
33 / 105
<body>
<div>
<nav>
</nav>
<h1>About Page</h1>
</div>
</body>
</html>
contact.blade.php
<!DOCTYPE html>
<html lang="en">
<head>
<title>Contact</title>
<style>
nav a {
padding: 0.5rem;
}
</style>
</head>
<body>
<nav>
</nav>
</body>
</html>
34 / 105
II. Blade Templates Layout
layout.blade.php

<html>
<head>
<title>App Name - @yield('title')</title>
<style>
header {
width: 100%;
background-color: yellow;
text-align: center;
}
footer {
width: 100%;
background-color: lightblue;
text-align: center;
}
nav a {
padding: 0.5rem;
}
</style>
<link rel="stylesheet" href="{{ asset('css/style.css') }}">
</head>
<body>
<header>
<div>
<h1>Header</h1>
</div>
</header>
<nav>
</nav>
<div class="container">
@yield('content')
35 / 105
</div>
<footer>
<h4>Footer</h4>
</footer>
</body>
</html>
style.css

header {
width: 100%;
text-align: center;
}
footer {
width: 100%;
text-align: center;
}
nav a {
padding: 0.5rem;
}
table {
text-align: center;
border-collapse: collapse;
}
td, th {
border : 2px solid green;
width: 80px;
}
.th {
font-weight: bold;
}
.tr {
36 / 105
}
.action {
width: 150px;
}
home.blade.php

@extends('layout')
@section('title', 'Home')
@section('content')
<h1>Home Page</h1>
@endsection
about.blade.php
!-- Stored in resources/views/home.about.php -->
@extends('layouts/ layout ')
@section('title', 'About')
@section('content')
<h1>About Page</h1>
@endsection
contact.blade.php

@extends('layout')
@section('title', 'Contact')
@section('content')
@endsection
web.php (without controllers)
37 / 105
<?php
Route::resource('clients',
App\Http\Controllers\ClientController::class);
Route :: get ('/page2', function () {

$T = ['Alami','Sqalli','Tazi'];
return view('page2', ['T' => $T]);
});

return view('page1');
});
});
})->name('about');
});
38 / 105
web.php (with controller MenuController)
<?php
Route::get('/',[MenuController::class, 'index']);
Route::get('/about',[MenuController::class, 'about'])-
>name('about');
Route::get('/contact',[MenuController::class, 'contact']);
 Ou bien :
web.php
Route::get('/','App\Http\Controllers\MenuController@index');
Route::get('/about','App\Http\Controllers\MenuController@about')
->name('about');
Route::get('/contact','App\Http\Controllers\MenuController@contact');
MenuController.php
<?php

{
}

39 / 105
}

}
}
2. Créer une méthode de contrôleur Laravel

 Présentation
 Un contrôleur laravel peut contenir différentes méthodes. Chaque
méthode peut avoir l’argument $request comme paramètre de fonction
par défaut.
Il s’agit essentiellement d’un objet de requête contenant vos variables de
formulaire, vos données de session ou vos informations de cookie.
 Une méthode de contrôleur peut répondre via différents types de
réponses, certains d’entre eux sont mentionnés ci-dessous :
 Texte brut
 Json Array
 Vue HTML ou blade
 XML
 Téléchargement de fichier
 Sortie PDF ou image sur navigateur directement etc …
a) Exemple de rendu de texte brut
<?php
class UserController extends Controller

{
function exemple()
{
return "Hello, Mohamed ALI";
}
}
40 / 105
b) Rendre un fichier de vue blade situé dans le dossier resources/views
<?php

{
function example()
{
return view("dashboard");
}
}
c) Rendre le tableau en tant que tableau json ou json
<?php

{
function example()
{
// render array as json
return [1, 2, 3];
// render json array

return response()->json([
"name" => "Sandip Patel"
]);
}
}
d) Rendre un texte avec des en-têtes supplémentaires
<?php
41 / 105

{
function example()
{
return response('Hello World', 200)
->header('Content-Type', 'text/plain');
return response($content)
->header('Content-Type', $type)
->header('X-Header-One', 'Header Value1')
->header('X-Header-Two', 'Header Value2');
}
}
e) Rendre un fichier ou un pdf
<? php

{
function example()
{
// render a file directly on broswer
// i.e. image or pdf file
return response()->file($pathToFile);
}
}
f) Télécharger le fichier de rendu
<?php
42 / 105
{
function example()
{
// download a file with given path
return response()->download($pathToFile);
// download a file with given path with different name and

// pass some extra headers along with the new file name
return response()->download($pathToFile, $name, $headers);
// delete the file once download completes

return response()->download($pathToFile)->deleteFileAfterSend();
}
}
g) Redirection vers des URL internes ou externes
<?php

{
function example()
{
// redirect to last page with
// submitted form data
return back()->withInput();
// redirect to user/dashboard page

return redirect('user/dashboard');
// redirect with named route

return redirect()->route('login');
43 / 105
// redirect with named route by passing variables
return redirect()->route('profile', ['id' => 1]);
// redirect to specific controller method

return redirect()->action('HomeController@index');
// redirect to external url

return redirect()->away('https://www.google.com');
// redirect with flash session message

return redirect('dashboard')->with('success',
'Profile updated!');
}
}
III. Laravel Response

3. HTTP responses
return response()->json([
'message' => 'Hello, World!'
]);
});
1. Response types :
a) Basic response
return response('Hello World', 200);
});
44 / 105
return response()->view('welcome');
});
a) HTML response
return response()->view('welcome',['name'=> 'Ali',]);
});
Welcome.blade.php
<h1>Home Page</h1>
<h2>Name : {{$name}}</h2>
b) JSON response
Route::get('/users', function () {
$users = [
['userid' => 1, 'name' => 'Alex'],
['userid' => 2, 'name' => 'Jane'],
];
return response()->json($users);
});
45 / 105
c) redirect response
 Route /signin
Route::get('/signin', function () {
// Action: user authenticated
// Create a redirect response using the redirect helper function:

return redirect('/dashboard');
// or
// Use the response() helper function to create a redirect response:

return response()->redirect('/dashboard');
});
 Route /dashboard
Route::get('/dashboard', function () {
return view('dashboard');
});
Route '/dashboard' nommée

Route::get('/signin', function () {
// Action: user authenticated
// Create a redirect response using the redirect

helper function:
return redirect(route('dashboard'));
// or
// Use the response() helper function to create a

redirect response:
46 / 105
return response()->redirect(route('dashboard'));
});
Route::get('/dashboard', function () {
return view('dashboard');
})->name('dashboard');
d) download response
Route::get('/download', function () {
// return download('F:\premiers-pas-avec-les-
winforms.pdf');
// or
return response()->download('F:\premiers-pas-avec-
les-winforms.pdf');
});
a) File response
Route::get('/download', function () {
return response()->download('F:\premiers-pas-avec-
les-winforms.pdf');
// or
return response()->file('F:\premiers-pas-avec-les-
winforms.pdf');
// or
return response()->stream('F:\premiers-pas-avec-les-
winforms.pdf');
});
IV. Acceder à une base de données
47 / 105
1. Connexion à une base de données MySQL avec Laravel
 Le Framework Laravel permet une interaction très facile avec les BD à
travers l’ORM Eloquent.
 Laravel supporte initialement quatre SGBD :
• MySQL
• PostgreSQL
• SQLite
• SQL Server
 Dans ce cours, nous utiliserons MySQL, qui est l’une des plateformes les
plus populaires et gratuites pour
développement.
 Laravel utilise The PHP Data Objects (PDO), qui est une interface
légère et cohérente pour accéder bases de données en PHP.
a) Créer une base de données MySQL
 Nous devons d’abord créer une base de données (Vente). Nous pouvons
utiliser soit phpMyAdmin de WampServer ou l’interface Workbench.
 Création de la BD Vente
Create database Vente;
Use Vente;
 Création de la table Client

Create Table Client (
CodeCl int Not Null primary key,
Nom VarChar(40) Not Null,
Ville VarChar(30)
);
 Insertions dans la table Client

Insert Into Client Values(1,'Alami','Fes');
Insert Into Client Values(2,'Naji','Casa');
Insert Into Client Values(3,'Sqalli','Fes');
Insert Into Client Values(4,'Wahbi','Rabat');
b) Configuration de la base de données dans Laravel

 Dans un premier temps, nous avons besoin de paramétrer l’accès à la
base de données.
48 / 105
 Toutes les configurations de la base de données prise en charge sont
stockées dans config/database.php. Ce fichier contient des détails
spécifiques à la connexion à une base de données.
 Ce fichier spécifie également la connexion par défaut pour une base de
données qui est MySQL.
 Mais c’est dans le fichier .env du répertoire racine de l’application que
nous allons utiliser pour configurer l’accès à la base de données.
c) Connecter votre projet Laravel à une base de données MySQL
 La connexion d’un projet laravel à une base de données MySQL est

relativement simple.
 Maintenant, nous allons créer une vue dans le
répertoire resources/views avec le nom page1.blade.php.
 Écrivez le code ci-dessous dans le fichier.
page1.blade.php.
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Laravel</title>
</head>
<body>
<h1>Page1</h1>
<?php
if (DB::connection()->getPdo()) {
echo "Connexion réussie à la BD => "
.DB::connection()->getDatabaseName();
}
$clients = DB::table('client')->get();
echo "<br>";
49 / 105
echo "Nombre de clients : ".count($clients);
echo "<br>";
echo "Nom : ".$clients[0]->Nom;
?>
</body>
</html>
Et une route :
return view('page1');
});
Avec la gestion d’exceptions :

<?php
try {
if(DB::connection()->getPdo())
{
echo "Successfully connected to the database => "
.DB::connection()->getDatabaseName();
}
}
catch (Exception $e) {
echo "Unable to connect";
}
?>
2. Eloquent ORM de Laravel

 L’une des caractéristiques les plus importantes du framework laravel est
qu’il est livré avec ORM (Object Relation Mapping) intégré appelé
Eloquent ORM.
50 / 105
 L’ORM fonctionne avec des objets de base de données et est utilisé pour
établir des relations avec des tables de base de données. Chaque table
de la base de données est mappée avec un modèle éloquent particulier.
 L’objet modèle contient diverses méthodes pour récupérer et mettre à
jour les données de la table de base de données.
 Eloquent ORM peut être utilisé avec plusieurs bases de données en
implémentant ActiveMethod.
 Eloquent ORM rend facile l’exécution des opérations CRUD (Créer, Lire,
Mettre à jour, Supprimer) sur le modèle Laravel.
3. Comment fonctionne Eloquent?
 Il s’agit d’un modèle architectural où le modèle créé dans la
structure Model-View-Controller (MVC) correspond à une table dans la
base de données.
 L’avantage est que les modèles effectuent des opérations de base de
données courantes sans coder de longues requêtes SQL.
 Les modèles permettent d’interroger des données dans vos tables,

ainsi que d’insérer de nouveaux enregistrements dans des tables.
 Tout ce que vous avez à faire est de définir les tables de la base de
données et les relations entre elles, et Eloquent fera le reste du travail.
4. Configuration de Laravel
 Voici les étapes pour commencer:
1) Créer des migrations à l’aide de la console Artisan

2) Créez des modèles éloquents
3) « Seed » la base de données
 Migration
a) Présentation
 La migration est un processus de gestion de votre base de
données en écrivant PHP plutôt que SQL.
 La migration est un type de contrôle de version pour votre base
de données. Il permet à une équipe de modifier le schéma de la
base de données et de rester à jour sur l’état actuel du schéma.
51 / 105
 Les Migrations sont une sorte de contrôleur de version pour la
BD, permettant, à une équipe, de modifier et partager le schéma
d’une BD facilement.
b) Créer une migration

 Pour créer une migration, vous pouvez utiliser la commande
Artisan suivante :
php artisan make:migration create_clients_table
 La migration sera placée dans votre

dossier database/migrations et contiendra un horodatage qui
permet au framework de déterminer l’ordre des migrations.
c) Exécuter une migration
 L’exécution d’une Migration permet de créer la table dans la BD

avec le schéma défini dans la Migration.
La commande permettant d’exécuter les Migrations est :
php artisan migrate

 Il existe une commande qui permet de créer une Migration avec le
Model :
php artisan make:model --migration NomModel

 Ou bien :
php artisan make:model -m NomModel
5. Exemple pratique :
a) Création de la migration de création de la table clients :
php artisan make:migration create_clients_table --create=clients
52 / 105
public function up(): void
{
Schema::create('clients', function (Blueprint $table)
{
$table->integer('CodeCl');
$table->string('Nom', 40);
$table->string('Ville', 40);
$table->primary('CodeCl');
});
}
php artisan migrate
 Créer une migration d’un seul fichier

php artisan migrate --path=database/migrations/2024_02_29_010423_create_clients_table.php
 Annuler ou rafraichir une migration
Pour annuler une migration :

PHP artisan migrate:rollback
Dans ce cas les méthodes down des migrations sont exécutées et les
tables sont supprimées.
Pour annuler et relancer en une seule opération on utilise la commande

refresh :
PHP artisan migrate:refresh
53 / 105
php artisan migrate:refresh --path=database/migrations/2024_02_29_010423_create_clients_table.php
b) Créer un fichier de seeds :
 Générer le fichier de seeds
php artisan make:seeder ClientsTableSeeder
class ClientsTableSeeder extends Seeder

{
/**
* Run the database seeds.
*/
public function run(): void
{
\DB::table('clients')->insert([[
'CodeCl' => 1,
'Nom' => 'Alami',
'Ville' => 'Fes'
],
[
'CodeCl' => 2,
'Nom' => 'Naji',
'Ville' => 'Casa'
],
[
'CodeCl' => 3,
'Nom' => 'Sqalli',
'Ville' => 'Fes'
]
]);
}
}
54 / 105
 Exécuter le Seeder
Exécuter le Seeder puis vérifier la table dans l’interface Workbench (ou
PhpMyAdmin) :
php artisan db:seed --class=ClientsTableSeeder
Workbench :
Use Vente;
Select * From clients;
Étape – 5: Ajouter une route de ressources
Web.php
Route::resource('clients', App\Http\Controllers\ClientController::class);
Étape 6: Ajouter un contrôleur et un modèle
php artisan make:controller ClientController --resource --model=Client
ClientController.php (Vide)
<?php
use App\Models\Client;

{
public function index() { // }
public function create() { // }
public function store(Request $request) { // }
public function show(Client $client) { // }
public function edit(Client $client) { // }
public function update(Request $request, Client $client) { // }
public function destroy(Client $client) { // }
}
Client.php (Vide)
55 / 105
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
class Client extends Model

{
use HasFactory;
}
Ajout du code de la méthode index() et du Modèle Client.php :

<?php

{
public function index() {
$clients = Client::all();
return view('client.index',['clients' => $clients]);

}
public function create() { // }
public function store(Request $request) { // }
public function show(Client $client) { // }
public function edit(Client $client) { // }
public function update(Request $request, Client $client) { // }
public function destroy(Client $client) { // }
}
Client.php
<?php
56 / 105

{
use HasFactory;
public $primaryKey = 'CodeCl';
protected $fillable = [
'CodeCl', 'Nom', 'Ville', 'created_at'
];
}
Create a folder called client in resources/views and three views in

it like this:
Index.blade.php

@extends('layout')
@section('title', 'Client Home')
@section('content')
<h1>Client Home Page</h1>
<table>
<tr class="th">
<th>Code</th>
<th>Nom</th>
<th>Ville</th>
<th class="action">Action</th>
</tr>
@foreach ($clients as $client)
<tr class="tr">
<td>{{ $client->CodeCl }}</td>
<td>{{ $client->Nom }}</td>
<td>{{ $client->Ville }}</td>
<td class="action">
<form action="{{ route('clients.destroy',
57 / 105
$client->CodeCl) }}" method="POST">
<a href="{{ route('clients.show',

$client->CodeCl) }}">Show</a>
<a href="{{ route('clients.edit',

$client->CodeCl) }}">Edit</a>
@csrf
@method('DELETE')
<button type="submit">Delete</button>
</form>
</td>
</tr>
@endforeach
</table>
@endsection
V. Les formulaires sous Laravel
1. Créer un formulaire dans Laravel

create.blade.php
@extends('layouts/layout')
@section('title', 'Create Form')
@section('content')
<h1>Create Client</h1>
<form method="POST" action="{{
action('App\Http\Controllers\ClientController@store') }}">
@csrf
<div>
<label>Code</label>
<input type="text" name="code" id="code">
</div>
58 / 105
<div>
<label>Nom</label>
<input type="text" name="nom" id="nom">
</div>
<div>
<label>Ville</label>
<input type="text" name="ville" id="ville">
</div>
<button type="submit">Submit</button>
</form>
@if ($errors->any())
<div>
<ul>
@foreach ($errors->all() as $error)
<li>{{ $error }}</li>
@endforeach
</ul>
</div>
@endif
@endsection
Web.php
Route::resource('clients', App\Http\Controllers\ClientController::class);
https://laravel.com/docs/10.x/eloquent#inserts
59 / 105
<?php

{
{

{
return view('client.create');
}

{
// Validation formulaire
$validated = $request->validate([
'code' => 'required',
'nom' => 'required',
'ville' => 'required',
]);
// Client::create($request->all());
// Store data in database

$client = new Client;
$client->CodeCl = $request->input('code');
$client->Nom = $request->input('nom');
$client->Ville = $request->input('ville');
$client->created_at = now();
$client->updated_at = now();
60 / 105
// $client = Client::create([
// 'CodeCl' => $request->input('code'),
// 'Nom' => $request->input('nom'),
// 'Ville' => $request->input('ville'),
// ]);
$client->save();
// return back()->with('success', 'Les données ont été

enregistrées avec succès.');
// return back()
return redirect('/clients');
// dd('OK'); // Pour verifier que l'accès à store() se
fait
}
public function show(Client $client)

{
return view('client.show');
public function edit(Client $client)

{
return view('client.edit',['client' => $client]);
// return view('client.edit')->with('client',$client);
}
public function update(Request $request, Client $client)

{
// $cl = Client::where('CodeCl', $client->CodeCl)
// ->update([
// 'CodeCl' => $request->input('code'),
// 'Nom' => $request->input('nom'),
// 'Ville' => $request->input('ville'),
// ]);
$client->save();
61 / 105
}
public function destroy(Client $client)

{
// dd($client->Nom); // pour verifier
$client->delete();
}
}
edit.blade.php
@section('title', 'Edit Page')
@section('content')
<h1>Edit Client</h1>
route('client.update',$client) }}">
@csrf
@method('PUT')
<div>
<label>Code</label>
<input type="text" name="code" id="code"
value="{{$client->CodeCl}}">
</div>
<div>
<label>Nom</label>
<input type="text" name="nom" id="nom"
value="{{$client->Nom}}">
</div>
<div>
<input type="text" name="ville" id="ville"
value="{{$client->Ville}}">
62 / 105
</div>
<button type="submit">Update</button>
</form>
@endsection
index.blade.php (version complète)

@section('title', 'Client Home')
@section('content')
<h1>Client Home Page</h1>
<a href="{{ route('client.create') }}" style="margin-left:
350px;">Add</a>
<table>
<tr class="th">
<th>Code</th>
<th>Nom</th>
<th>Ville</th>
</tr>
@foreach ($clients as $client)

<tr class="tr">
<td>{{ $client->CodeCl }}</td>
<td>{{ $client->Nom }}</td>
<td>{{ $client->Ville }}</td>
<td class="action">
<form action="{{ route('client.destroy',
$client) }}" method="POST">
<a href="{{ route('client.show',
$client) }}">Show</a>
<a href="{{ route('client.edit',

$client) }}">Edit</a>
@csrf
@method('DELETE')
63 / 105
<button type="submit">Delete</button>
</form>
</td>
</tr>
@endforeach
</table>
@endsection
style.css
header {
width: 100%;
text-align: center;
64 / 105
}
footer {
width: 100%;
text-align: center;
}
nav a {
padding: 0.5rem;
}
table {
text-align: center;
border-collapse: collapse;
}
td, th {
border : 2px solid green;
width: 80px;
padding: 0%;
}
.th {
font-weight: bold;
}
.tr {
}
.action {
width: 150px;
}
layout.blade.php (Vide)

<html>
65 / 105
<head>
<title>App Name - @yield('title')</title>
<style>
</style>
</head>
<body>
<header>
<div>
<h1>Header</h1>
</div>
</header>
<nav>
<a href="/page1">Page1</a>
</nav>
@yield('content')
</div>
<footer>
<h4>Footer</h4>
</footer>
</body>
</html>
layout.blade.php (Option Clients dans le menu)

<!DOCTYPE html>
<html lang="en">
<head>
66 / 105
<title>@yield('title')</title>
</head>
<body>
<header>
<h1>Header</h1>
</header>
<nav>
<a href="/client">Clients</a>
</nav>
@yield('content')
</div>
<footer>
<h4>Footer</h4>
</footer>
</body>
</html>
Validation :
create.blade.php
67 / 105
@section('title', 'Create Form')
@section('content')
<h1>Create Client</h1>
action('App\Http\Controllers\ClientController@store') }}">
@csrf
<div>
<label>Code</label>
<input type="text" name="code" id="code">
</div>
<div>
<label>Nom</label>
<input type="text" name="nom" id="nom">
</div>
<div>
<input type="text" name="ville" id="ville">
</div>
<button type="submit">Submit</button>
</form>
<div>
<ul>
@endforeach
</ul>
</div>
@endif
@endsection
edit.blade.php
68 / 105
@section('title', 'Edit Page')
@section('content')
route('client.update',$client) }}">
@csrf
@method('PUT')
<div>
<label>Code</label>
value="{{$client->CodeCl}}">
</div>
<div>
<label>Nom</label>
value="{{$client->Nom}}">
</div>
<div>
value="{{$client->Ville}}">
</div>
<div>
<ul>
@endforeach
</ul>
</div>
@endif
<button type="submit">Update</button>
</form>
@endsection
69 / 105
ClientController
<?php

{
{

}

{
return view('client.create');
}

{
]);
// Client::create($request->all());
$client = new Client;

$client->created_at = now();
$client->updated_at = now();
70 / 105
$client->save();
return redirect('/client');
}

{
return view('client.show',['client' => $client]);
}

{

{
]);
// Update data
$client->save();

{
$client->delete();
71 / 105
}
}
Exemples :
request()->validate([
'email' => ['required', 'email'],
'password' => ['required', 'confirmed', 'min:8'],
'password_confirmation' => ['required'],
]);
$request->validate([
'title' => 'bail|required|unique:posts|max:255',
'body' => 'required',
]);
bail : stop running validation rules for the field after the first validation failure.
A Note on Nested Attributes
72 / 105
'title' => 'required|unique:posts|max:255',
'author.name' => 'required',
'author.description' => 'required',
]);
'title' => 'required|unique:posts|max:255',
'body' => 'required',
'publish_at' => 'nullable|date',
]);
'start_date' => 'required|date|after:tomorrow'

'finish_date' => 'required|date|after:start_date'
before:date
before_or_equal:date
between:min,max
boolean
date
image
date_equals:date
decimal:min,max
different:field
distinct
'foo.*.id' => 'distinct:ignore_case'
doesnt_start_with:foo,bar,...
doesnt_end_with:foo,bar,...
ends_with:foo,bar,...
exclude
exclude_if:anotherfield,value
exists:table,column
'zones' => [
'required',
Rule::in(['first-zone', 'second-zone']),
],
Validator::make($input, [
'airports' => [
73 / 105
'required',
'array',
],
'airports.*' => Rule::in(['NYC', 'LIT']),
]);
use Illuminate\Validation\Rule;
Validator::make($data, [
'toppings' => [
'required',
Rule::notIn(['sprinkles', 'cherries']),
],
]);
nullable|numeric|required|required_if:anotherfield,value,...
'photo' => ['required', 'extensions:jpg,png'],
// image
'avatar' => 'dimensions:min_width=100,min_height=200'
'avatar' => 'dimensions:ratio=3/2'
// Validate that a string is exactly 12 characters

long...
'title' => 'size:12';
// Validate that a provided integer equals 10...

'seats' => 'integer|size:10';
// Validate that an array has exactly 5 elements...

'tags' => 'array|size:5';
// Validate that an uploaded file is exactly 512

kilobytes...
'image' => 'file|size:512';
Relation One To Many (Eloquent)

Migration de 2 tables : clients et commandes
74 / 105
php artisan make:migration create_clients_table
php artisan migrate --path=database/migrations/

2024_04_22_011421_create_clients_table.php
php artisan make:migration create_commandes_table
php artisan migrate --path=database/migrations/

2024_05_07_001637_create_commandes_table.php
php artisan make:seeder ClientsTableSeeder
php artisan db:seed --class=ClientsTableSeeder
php artisan make:seeder CommandesTableSeeder
php artisan db:seed --class=CommandesTableSeeder
2024_04_22_011421_create_clients_table.php
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
class CreateClientsTable extends Migration

{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('clients', function (Blueprint $table) {
$table->string('Nom', 40);
$table->string('Ville', 40);
$table->primary('CodeCl');
75 / 105
$table->timestamps();
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('clients');
}
}
2024_05_07_001637_create_commandes_table.php
<?php
class CreateCommandesTable extends Migration

{
/**
* Run the migrations.
*
* @return void
*/
{
Schema::create('commandes', function (Blueprint $table) {
$table->integer('NumCom');
$table->date('DateCom');
$table->foreign('CodeCl')
->references('CodeCl')
->on('clients');
76 / 105
$table->primary('NumCom');
});
}
/**
* Reverse the migrations.
*
* @return void
*/
{
Schema::dropIfExists('commandes');
}
}
ClientsTableSeeder.php
<?php
namespace Database\Seeders;
use Illuminate\Database\Seeder;
class ClientsTableSeeder extends Seeder

{
/**
*
* @return void
*/
public function run()
{
\DB::table('clients')->insert([[
'CodeCl' => 1,
'Nom' => 'Alami',
'Ville' => 'Fes'
],
[
77 / 105
'CodeCl' => 2,
'Nom' => 'Naji',
'Ville' => 'Casa'
],
[
'CodeCl' => 3,
'Nom' => 'Sqalli',
'Ville' => 'Fes'
]
]);
}
}
CommandesTableSeeder.php
<?php
namespace Database\Seeders;
use Illuminate\Database\Seeder;
class CommandesTableSeeder extends Seeder

{
/**
*
* @return void
*/
public function run()
{
\DB::table('commandes')->insert([
[
'NumCom' => 100,
'DateCom' => '2024-04-01',
'CodeCl' => 1
],
[
'NumCom' => 101,
'DateCom' => '2024-04-04',
'CodeCl' => 1
],
78 / 105
[
'NumCom' => 102,
'DateCom' => '2024-04-10',
'CodeCl' => 2
]
]);
}
}
Relation One To Many: hasMany et belongsTo

Création des Modèles Client et Commande :
php artisan make:model Client
php artisan make:model Commande
Client.php
<?php

{
use HasFactory;
public $primaryKey = 'CodeCl';
'CodeCl', 'Nom', 'Ville'
];
public function commandes()

{
return $this-
>hasMany(Commande::class,'CodeCl','CodeCl');
// return $this->hasMany('App\Commande');
}
}
79 / 105
Commande.php
<?php
class Commande extends Model

{
use HasFactory;
public $primaryKey = 'NumCom';
'NumCom', 'DateCom', 'CodeCl'
];
public function client()

{
return $this-
>belongsTo(Client::class,'CodeCl','CodeCl');
// return $this->belongsTo('App\Models\Client');
}
}
On peut donc récupérer les objets commandes d’un client :

$commandes = Client::find(1)->commandes;
foreach ($commandes as $commande) {

// ...
}
Ou encore récupérer le nom d’un client ayant une commande :

use App\Models\Commande;
$commande = Commande::find(100);
$Nom = $commande->client->Nom;
80 / 105
Ou bien si on veut créer les modèles et les migrations en même temps :
php artisan make:model Client --migration
php artisan make:model Commande --migration
Si on veut créer les controllers avec ressources (méthodes) et les modèles

correspondants :
php artisan make:controller ClientController --resource

--model=Client
php artisan make:controller CommandeController --resource

--model=Commande
Edit.blade.php (Avec affichage des commandes du client):

@section('title', 'Show Page')
@section('content')
<form method="POST" action="{{ route('client.index') }}">
@csrf
@method('GET')
<div>
<label>Code</label>
value="{{$client->CodeCl}}" disabled>
</div>
<div>
<label>Nom</label>
value="{{$client->Nom}}" disabled>
</div>
<div>
81 / 105
value="{{$client->Ville}}" disabled>
</div>
@if (sizeof($client->commandes) > 0)
<table>
<tr class="th">
<th>NumCom</th>
<th>Date</th>
</tr>
@foreach ($client->commandes as $com)

<tr class="tr">
<td>{{ $com->NumCom }}</td>
<td>{{ $com->DateCom }}</td>
<td class="action">
<a href="#">Detail</a>
</td>
</tr>
@endforeach
</table>
@endif
<button type="submit">Retour</button>
</form>
@endsection
Eloquent (Exemples de requêtes sur les données)
82 / 105
ClientController
<?php

{
{
$clients = Client::where('Ville', 'Fes')->get();
$clients = Client::whereIn('CodeCl', [1, 2])->get();
$clients = Client::whereIn('Ville', ['Fes', 'Casa'])->get();
$clients = Client::whereIn('Nom', ['Naji', 'Sqalli'])->get();
$clients = Client::whereNotIn('Nom', ['Naji', 'Sqalli'])->get();
$clients = Client::find(1); // Ne marche pas
$clients = $clients->diff(Client::whereIn('CodeCl', [1, 2])->get());
$clients = $clients->diff(Client::whereNotIn('CodeCl', [1, 2])-
>get());
$clients = $clients->except([1, 2]);
$clients = $clients->only([1, 2]);

+

{
//
}

{
//
83 / 105
}

{
return view('client.show',['client' => $client]);
}

{

{
$client->save();

{
$client->delete();
}
}
Autres exemples de CRUD : (Exercice)

https://www.akilischool.com/cours/laravel-crud-avec-upload-dimage
84 / 105
Accéder aux données
// Tout obtenir
$todos = LeNomDeVotreTableEnBase::all();
// Ou pour l’enregistrement avec l’identifiant « 42 »

$todo = LeNomDeVotreTableEnBase::find(42);
// Obtenir, mais filtrer et ordonné et avec une limite

$todos = LeNomDeVotreTableEnBase::where('temine', 1)-
>orderBy('id', 'desc')->take(10)->get();
// Ou avec un where
$users = User::where('votes', '>', 100)->get();
Requêter les données

Nous avons vu comment définir les relations, mais comment les utiliser ? C’est très simple, vous
pouvez utiliser les méthodes de relations comme si elles étaient des méthodes de modèle.
https://cours.brosseau.ovh/cheatsheets/laravel/
// Récupérer les commentaires d’un post

$comments = App\Post::find(1)->comments()->get();
// Récupérer les commentaires d’un post et les ordonner par

date
$comments = App\Post::find(1)->comments()-
85 / 105
>orderBy('created_at', 'desc')->get();
// Récupérer les commentaires d’un post et les ordonner par

date et avec une limite
$comments = App\Post::find(1)->comments()-
>orderBy('created_at', 'desc')->take(10)->get();
// Utiliser le with pour récupérer les données en une seule

requête
// Ici on récupère les posts avec leurs commentaires
$posts = App\Post::with('comments')->get();
// Obtenir les articles d’un utilisateur

$articles = App\User::find(1)->articles()->get();
// Réaliser plusieurs jointures avec le with

// Ici on récupère les utilisateurs avec leurs rôles et
leurs articles
$users = App\User::with('roles', 'posts')->get();
// Jointure conditionnelle obtenir les articles d’un

utilisateur dont le titre contient « Laravel »
$articles = App\User::find(1)->articles()->where('title',
'like', '%Laravel%')->get();
// Obtenir un utilisateurs avec les posts et les

commentaires via le with
$users = App\User::with('posts.comments')->get();
Les Middlewares :
Un middleware permet d’intercepter une requête de l'utilisateur.
Nous pouvons, avant l'exécution de contrôleur (l'affichage d’une vue, la
création d'un nouveau message, la modification du mot de passe…),
effectuer des tests et rediriger si nécessaire l’utilisateur.
Comment créer un middleware ?

Nous pouvons créer un middleware avec la commande Artisan :
php artisan make:middleware NomDuMiddleware
86 / 105
Exemple :
php artisan make:middleware Auth
Le fichier est : app/Http/Middleware/Auth.php
<?php
namespace App\Http\Middleware;
use Closure;
class Auth
{
public function handle(Request $request, Closure $next)

{
// dump('Nous sommes dans le Auth middleware');
// die();
// dd('Bonjour');
// return redirect('/');
if (auth()->guest()) {
// flash("Vous devez être connecté pour voir
cette page.")->error();
return redirect('/login');
}
return $next($request);
}
}
 Dans le nouveau fichier créé par Laravel, il y a une simple

classe Auth avec une seule fonction handle($request, Closure $next).
 La fonction handle() prend en paramètre la requête de l'utilisateur
(identique à la fonction request()) et une fonction $next qui contient la
suite de l'application.
87 / 105
 Nous voulons pouvoir utiliser notre middleware sur plusieurs
routes/contrôleurs différents, nous ne devons donc pas savoir ce qu'il y a
après.
 La variable $next peut donc contenir soit la modification du mot de passe,
soit l'affichage d'une vue mon-compte ou encore l'ajout d'un nouveau
message.
 Pour le moment notre middleware return $next($request); cela signifie à
Laravel : « Exécute le reste de l'application et ne fait rien. ».
Activation du middleware
Le middleware peut être activé sur n'importe quelle route.

Dans le fichier routes/web.php, nous pouvons utiliser la fonction
->middleware() pour demander à Laravel d'activer le middleware :
Route::resource('/client', App\Http\Controllers\ClientController::class)
->middleware('App\Http\Middleware\Auth');
Exemlpe 1 :
<?php
use Closure;
class Auth
{

{
dd('Nous sommes dans le Auth middleware');
}
}
88 / 105
Exemlpe 2 : (redirection vers contact page)
<?php
use Closure;
class Auth
{

{
return redirect('/contact');
}
}
89 / 105
Exemlpe 3 : (avec condition)
<?php
use Closure;
class Auth
{

{
$var = true; // Or false
if ($var) {
return redirect('/contact');
}
}
}
Maintenant que nous avons vu que l'activation du middleware fonctionne,

nous pouvons utiliser le « vrai » code :
Exemlpe 4 : (Redirect anonymous to Login Page)

<?php
use Closure;
class Auth
{

{
90 / 105
if (auth()->guest()) {
return redirect('/login');
}
}
}
91 / 105
Groupe de routes :
92 / 105
Groupes de routes (Partage de middleware st controller)
Les groupes de routes vous permettent de partager des attributs de route
comme les intergiciels sur un grand nombre de routes sans avoir à les
redéfinir sur chaque route.
Middleware
L’attribution d’un intergiciel à toutes les routes que nous avons nous permet
de les combiner dans un groupe, d’abord en utilisant la méthode group. Une
chose à considérer est que les intergiciels sont exécutés dans l’ordre dans
lequel ils sont appliqués au groupe :
Route:middleware(['AuthMiddleware', 'SessionMiddleware'])-> Group(

function () {
Route::get('/', function() {} );
Route::post('/upload-picture', function () {} );
});
Contrôleurs
Lorsqu’un groupe utilise le même contrôleur, nous pouvons utiliser la

méthode controller pour définir le contrôleur commun à toutes les routes de
ce groupe. Nous devons maintenant spécifier la méthode que l’itinéraire
appellera.
93 / 105
Route::controller(UserController::class)->group(function () {
Route::get('/orders/{userId}', 'getOrders');
Route::post('/order/{id}', 'postOrder');
});
Database : Migrations
1. Tables
 Creating Tables
Schema::create('users', function (Blueprint $table)

{
$table->id();
$table->string('name');
$table->string('email');
});
 Determining Table / Column Existence
if (Schema::hasTable('users')) {
// The "users" table exists...
}
if (Schema::hasColumn('users', 'email')) {
// The "users" table exists and has an "email" column...
}
 Updating Tables ( add columns or indexes to the table)
Schema::table('users', function (Blueprint $table) {

$table->integer('votes');
});
94 / 105
 Renaming / Dropping Tables
Schema::rename($from, $to);
Schema::drop('users');
Schema::dropIfExists('users');
2. Columns
 Creating Columns (add columns to the table)

});
 Available Column Types
$table->bigIncrements('id');
$table->bigInteger('votes');
$table->binary('photo');
$table->char('name', 100);
$table->dateTimeTz('created_at', $precision = 0);
$table->dateTime('created_at', $precision = 0);
$table->date('created_at');
$table->decimal('amount', $precision = 8, $scale = 2);
$table->double('amount', 8, 2);
95 / 105
$table->enum('difficulty', ['easy', 'hard']);
$table->float('amount', 8, 2);
$table->foreignId('user_id');
$table->foreignIdFor(User::class);
$table->id();
$table->id('num');
$table->increments('id'); // creates auto-incrementing column

as a primary key
$table->json('options');
$table->longText('description');
$table->set('flavors', ['strawberry', 'vanilla']);
$table->string('name', 100);
$table->text('description');
$table->year('birth_year');
 Column Modifiers (For example, to make the column "nullable")

$table->string('email')->nullable();
});
Modifier Description
->after('column') Place the column "after" another column (MySQL).
->autoIncrement() Set INTEGER columns as auto-incrementing (primary key).
->default($value) Specify a "default" value for the column.
->first() Place the column "first" in the table (MySQL).
96 / 105
->invisible() Make the column "invisible" to SELECT * queries (MySQL).
 Column Order
The after method may be used to add columns after an existing column in the
schema:
$table->after('password', function (Blueprint $table) {

$table->string('address_line1');
$table->string('address_line2');
$table->string('city');
});
 Modifying Columns
The change method allows you to modify the type and attributes of existing
columns. For example, you may wish to increase the size of a string column.

$table->string('name', 50)->change();
});
 Renaming Columns

$table->renameColumn('from', 'to');
});
 Dropping Columns

$table->dropColumn('votes');
});

$table->dropColumn(['votes', 'tel', 'email']);
});
3. Indexes
 Creating Indexes
 Renaming Indexes
 Dropping Indexes
97 / 105
 Foreign Key Constraints
Voir lien :
https://laravel.com/docs/10.x/migrations
Authentication (authentification)
Login.blade.phph (Login Page)

@section('title', 'Login Page')
@section('content')
<h1>Login Page</h1>
<form method="POST" action="{{route('tologin')}}">
@csrf
<div>
<label>Login :
</label>
<input type="text" name="login" id="login" >
@error('login')
<p>{{$message}}</p>
@enderror
</div>
<div>
<label>Password :</label>
<input type="text" name="password"
id="password">
@error('password')
<p>{{$message}}</p>
@enderror
</div>

<button type="submit" style="width:

100px;">Login</button><br>
</form>
@endsection
Web.php
Route::resource('/client',
App\Http\Controllers\ClientController::class)-
>middleware('App\Http\Middleware\Auth');
Route::get('/login',
'App\Http\Controllers\AuthController@login')-
>name("login");
Route::post('/tologin',
'App\Http\Controllers\AuthController@tologin')-
>name("tologin");
AuthController.php
<?php
use app\Http\Requests\LoginRequest;
class AuthController extends Controller

{
99 / 105
public function login(){
return view('auth.login');
}
public function toLogin(LoginRequest $request)

{
$validated = $request->validated();
if(auth()->attempt($validated))
{
session()->regenerate();
return redirect()-
>intended(route('client.index'));
}
return to_route('client')->withErrors(
[
"login"=>'Login ou mot de passe invalide'
])
->withInput(['login','password']);
}
LoginRequest.php
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class LoginRequest extends FormRequest

{
/**
* Determine if the user is authorized to make this
request.
*
* @return bool
*/
public function authorize() : bool
100 / 105
{
return true;
}
/**
* Get the validation rules that apply to the
request.
*
* @return array
*/
public function rules() : array
{
return [
"login"=>'required',
"password"=>'required|min:4'
];
}
}
<?php
class CreateUsersTable extends Migration

{
101 / 105
{
Schema::create('users', function (Blueprint
$table) {
$table->string('name');
$table->string('login')->unique();
$table->string('password');
});
}

{
Schema::dropIfExists('users');
}
}
https://laravel.com/docs/10.x/controllers
https://laravel-docs.readthedocs.io/en/latest/routing/
https://laravel.io/forum/form-action-does-not-go-to-the-right-controller
https://geekflare.com/fr/laravel-eloquent-model-relationship/
Créer un formulaire avec laravel

https://www.apprendre-laravel.fr/laraguide/2017-11-09-creer-un-formulaire
https://pusher.com/blog/laravel-mvc-use/
https://apcpedagogie.com/blade-templates/
https://pusher.com/blog/laravel-mvc-use/#controllers-creating-our-controller
https://www.w3schools.in/laravel/views
https://www.training-dev.fr/Cours/Laravel-8---Prendre-en-main-le-framework-avec-la-creation-d-un-blog/Front-le-panneau-d-
administration-partie-1
https://www.apprendre-laravel.fr/laraguide/2017-11-09-creer-un-formulaire
https://www.letecode.com/tutoriel-laravel-9-crud-pour-debutant-inserer-lire-modifier-et-supprimer
https://laravel.com/docs/10.x/blade
102 / 105
https://laravel.com/docs/10.x/eloquent-collections
https://morioh.com/a/34012c0b7093/creer-une-application-crud-de-base-avec-laravel-et-reactjs
https://code.tutsplus.com/fr/build-a-react-app-with-laravel-restful-backend-part-1-laravel-5-api--cms-
29442t
Q uelle est la différence entre URI et URL ? – L’URL signifier Uniform Resource Locator, qui est
utilisé pour identifier une ressource. Il s’agit d’un sous-ensemble d’URI. L’URI signifier Uniform
Resource Identifier offre un moyen plus simple et extensible d’identifier une ressource.
Un middleware, qu'est-ce que c'est ?

Présentation
Un middleware est un logiciel qui fournit des services et fonctionnalités unifiés aux applications,
pour permettre aux équipes de développement et d'exploitation de créer et déployer des
applications plus efficacement. Un middleware joue le rôle de lien entre les applications, les
données et les utilisateurs.
Quel est le rôle d'un middleware ?
Un middleware est un logiciel qui fournit des services et fonctionnalités unifiés aux applications,
pour permettre aux équipes de développement et d'exploitation de créer et déployer des
applications plus efficacement. Un middleware joue le rôle de lien entre les applications, les
données et les utilisateurs.
C'est quoi le middleware en Laravel ?
Maintenant je vais vous présenter les Middleware dans Laravel. Un Middleware est une mini-
application, une étape intermédiaire qui va envelopper les actions gérées par notre controller.
Elle est une sorte de sous-couche se plaçant entre la requête (request) et la réponse (response)
entre la vue et le controller.
103 / 105
https://laravel.com/docs/10.x/controllers#resource-controllers
Resource Controllers
If you think of each Eloquent model in your application as a "resource", it is typical to
perform the same sets of actions against each resource in your application. For
example, imagine your application contains a Photo model and a Movie model. It is likely
that users can create, read, update, or delete these resources.
Because of this common use case, Laravel resource routing assigns the typical create,
read, update, and delete ("CRUD") routes to a controller with a single line of code. To
get started, we can use the make:controller Artisan command's --resource option to
quickly create a controller to handle these actions:
php artisan make:controller PhotoController –resource
This command will generate a controller at app/Http/Controllers/PhotoController.php. The

controller will contain a method for each of the available resource operations. Next,
you may register a resource route that points to the controller:
use App\Http\Controllers\PhotoController;
Route::resource('photos', PhotoController::class);
This single route declaration creates multiple routes to handle a variety of actions on
the resource. The generated controller will already have methods stubbed for each of
these actions. Remember, you can always get a quick overview of your application's
routes by running the route:list Artisan command.
You may even register many resource controllers at once by passing an array to
the resources method:
Route::resources([
'photos' => PhotoController::class,
'posts' => PostController::class,
104 / 105
]);
Actions Handled by Resource Controllers
Verb URI Action Route Name
GET /photos index photos.index
GET /photos/create create photos.create
POST /photos store photos.store
GET /photos/{photo} show photos.show
GET /photos/{photo}/edit edit photos.edit
PUT/PATCH /photos/{photo} update photos.update
DELETE /photos/{photo} destroy photos.destroy
105 / 105

Guide de Cours Et TPs - M205 - Laravel - Fev 2024

Transféré par

Droits d'auteur :

Formats disponibles

Guide de Cours Et TPs - M205 - Laravel - Fev 2024

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Guide de Cours Et TPs - M205 - Laravel - Fev 2024

Transféré par

Droits d'auteur :

Formats disponibles

Laravel ‫المختصر المفيد في لغة‬

Et téléchargez le fichier : Composer-Setup.exe.

II. Créer un nouveau projet Laravel

composer global require laravel/installer

Changer de répertoire de travail en plaçant le terminal dans le repertoire www

Laravel new tp1_laravel

3. Créer un nouveau projet Laravel avec Composer – Méthode 2:

Créer un deuxième projet à la racine du serveur nommé tp2_laravel avec la

composer create-project laravel/laravel tp2_laravel

IV. Laravel Artisan

 Laravel Artisan: commandes utiles

php artisan list

php artisan help migrate

3) Pour créer un modèle

php artisan make:model NomDuModel

4) Vérifier la version de Laravel installée

php artisan -version

5) lancer le serveur , lancer le projet Laravel

php artisan serve

7) Exécuter toutes les migrations:

8) faire un retour en arrière pour la dernière migration

php artisan migrate : rollback

V. Lancer le projet Laravel

php artisan serve

2- Ouvrez le navigateur et tapez http://localhost/:8000, vous obtiendrez le

Les Vues (Views)

Les Contrôleurs (Controllers)

Cette architecture offre de nombreux avantages :

Toutes les commandes artisanales d’un projet Laravel doivent être

 Pour créer un modèle dans Laravel, exécutez la commande dans votre

Lien très Interressant :

VIII. Créer des Routes sous Laravel

Routage sous Laravel

1. Qu’est-ce que le routage sous Laravel

 Par défaut, Laravel s’installe avec un dossier de routes, pour gérer

 Le routage dans Laravel comprend trois catégories :

 Lorsqu’un utilisateur visite la page d’accueil, il est redirigé vers la

 Il a été stocké par défaut dans le dossier « vues » pendant

Route::get('1', function() { return 'Je suis la page 1 !'; });

 afficher des pages « view »

 Si vous ouvrez le dossier Route, vous verrez quatre fichiers :

 C’est ce fichier web.php que nous voulons examiner.

 Route : on utilise le routeur, appel statique de la classe qui gère le

 Création de nouvelles routes

La vue inscription.blade.php doit être créé :

 Cela signifie nous disons à Laravel de ne faire correspondre ces

 Mais que se passe-t-il s’il s’agit d’un formulaire POST, ou peut-être

 Il existe quelques autres options pour les méthodes permettant

Route::post('/', function () {});

 DELETE: Delete permet de supprimer une ressouce existante dans le

 La syntaxe (avec as)

 La syntaxe (méthode name)

<a href="{{ route('home') }}">

 Si vous utilisez le nom de la route pour la redirection :

5. Les paramètres des routes

 Partant de l’exemple précédent on peut se poser une question : est-il

 Les paramètres des routes sont toujours entre crochets {} et doivent

 Les paramètres de routage sont injectés dans le contrôleur ou la