Introduction
Pages statiques vs pages dynamiques :
- Page web statique : écrite directement en HTML et retourne le même contenu aux clients
- Page web dynamique : écrite avec un mélange de HTML et un langage permettant de générer un
contenu dynamique
Exemple de langage de programmation web : PHP, Java Entreprise Edition, ASP, Perl, etc.
Remarque : Javascript est un langage qui s’exécute côté client
Pages dynamiques et PHP : Lors du chargement d'une page PHP, c'est le serveur qui va lire, interpréter
et exécuter le code. Puis il renvoie le résultat, généralement sous la forme de code HTML au navigateur.
Ainsi le navigateur et l'utilisateur ne voient jamais le véritable code PHP exécuté.
PHP est un langage de programmation permettant de créer des scripts PHP. Un script est exécuté côté
serveur web pour générer un contenu HTML dynamique.
Exemple de serveurs web :
- WAMP : Windows Apache MySQL PHP
- LAMP : Linux Apache MySQL PHP
Requête HTTP(S) Script PHP
Apache PHP
HTML Code HTML
Données
Client
(exemple : Firefox) Base de données
Serveur (exemple : WAMP)
Framework : Permet de faciliter le développement des applications web
Exemples : Laravel, Symphony, Zend Framework, etc.
1
Les pages WEB
La création d’une page web statique nécessite les langages suivants :
- HTML : Hypertext Markup Language (HTML) correspond au code que vous utiliserez pour
structurer les différents contenus en ligne. Par exemple, le contenu sera‑t‑il un ensemble de
paragraphes, ou une liste à puces ? Y aura‑t‑il des images insérées ? Aurai‑je une table de
données ? Exemple de balises HTML : [Link]
- CSS : Le code Cascading Stylesheets (CSS) permet de mettre en forme votre site Web et
améliorer son apparence. Par exemple, voulez‑vous que le texte soit en noir ou en rouge ? Où le
contenu doit‑il être placé sur l'écran ? Quelles devront être les images de fond et les couleurs
utilisées pour décorer votre site web ? Exemple de balises CSS :
[Link]
- Javascript : c’est le langage de programmation à utiliser pour ajouter des fonctionnalités
interactives dans vos sites Web, par exemple des jeux, les événements déclenchés lorsqu'un
bouton est pressé ou lorsque des données sont entrées dans un formulaire, des effets de style
dynamiques, des animations, etc. Un code Javascript s’exécute côté client. Exemple de codes
Javascript : [Link]
Exemple de librairies (Framework) HTML/CSS/JS :
- Bootstrap : [Link]
- Semantic UI : [Link]
- Foundation : [Link]
- UIkit : [Link]
- Skeleton : [Link]
1) HTML
HTML est un langage de balises qui définit la structure de votre contenu. HTML se compose d'une série
d'éléments, utilisés pour entourer les diverses parties du contenu pour les faire apparaître d'une
certaine façon.
Syntaxe d’un élément HTML :
<p class="class-css">This is a paragraph with one line.</p>
Les composants de l’élément précédent sont :
- La balise ouvrante : <p>
- La balise fermante : </p>
- Le contenu : « This is a paragraph with one line. »
- Les attributs : « class="class-css" »
2
Exemple d’une page HTML :
<!DOCTYPE html>
<html>
<head>
<title>Page Title</title>
</head>
<body>
<h1>This is a Heading</h1>
<p>This is a paragraph.</p>
</body>
</html>
2) CSS
Le code CSS peut être placé dans les 3 emplacements suivants :
- Dans un fichier indépendant
- Dans un fichier HTML entouré dans l’élément « style »
- Dans l’attribut « style » d’un élément HTML
Exemple 1 : code CSS dans un fichier indépendant
Fichier [Link]
h1 {
color: blue;
text-align: center;
}
p {
font-family: verdana;
font-size: 20px;
}
Fichier [Link]
<!DOCTYPE html>
<html>
<head>
<title>Développement WEB</title>
<link rel="stylesheet" href="assets/css/[Link]">
</head>
<body>
<h1>Le code CSS</h1>
<p>Comment utiliser les fichiers CSS dans une page HTML</p>
</body>
</html>
3
Exemple 2 : code CSS dans un fichier HTML entouré dans l’élément « style »
<!DOCTYPE html>
<html>
<head>
<title>Développement WEB</title>
<style>
h1 {
color: blue;
text-align: center;
}
p {
font-family: verdana;
font-size: 20px;
}
</style>
</head>
<body>
<h1>Le code CSS</h1>
<p>Comment utiliser le code CSS dans une page HTML</p>
</body>
</html>
Exemple 3 : code CSS dans un l’attribut « style » d’un élément HTML
<!DOCTYPE html>
<html>
<head>
<title>Développement WEB</title>
</head>
<body>
<h1 style="color: blue; text-align: center;">Le code CSS</h1>
<p>Comment utiliser le code CSS dans l’attribut d’un élément HTML</p>
</body>
</html>
3) Javascript
Le code Javascript peut être placé dans les 3 emplacements suivants :
- Dans un fichier indépendant
- Dans un fichier HTML entouré dans l’élément « script »
- Dans un attribut d’un élément HTML
Exemple 1 : code Javascript dans un fichier indépendant
Fichier [Link]
function myFunction() {
[Link]("demo").innerHTML = Date();
}
4
Fichier [Link]
<!DOCTYPE html>
<html>
<head>
<title>Développement WEB</title>
<script src="assets/js/[Link]"></script>
</head>
<body>
<h1>Le code JavaScript </h1>
<button type="button" onclick="myFunction()">Click to show Time.</button>
<p id="demo"></p>
</body>
</html>
Exemple 2 : code Javascript dans un fichier HTML entouré dans l’élément « script »
<!DOCTYPE html>
<html>
<head>
<title>Développement WEB</title>
<script>
function myFunction() {
[Link]("demo").innerHTML = Date();
}
</script>
</head>
<body>
<h1>Le code JavaScript </h1>
<button type="button" onclick="myFunction()">Click to show Time.</button>
<p id="demo"></p>
</body>
</html>
Exemple 3 : code CSS dans un attribut d’un élément HTML
<!DOCTYPE html>
<html>
<head>
<title>Développement WEB</title>
</head>
<body>
<h1>Le code JavaScript </h1>
<button type="button" onclick="[Link]("demo").innerHTML=Date();">
Click to show Time.
</button>
<p id="demo"></p>
</body>
</html>
4) Bootstrap
Bootstrap permet de créer des sites web rapides et réactifs (responsive) qui s’adaptent avec la taille de
l’écran du client.
5
Bootstrap est un framework open source pour le développement web front-end. Il fournit une librairie
CSS et JavaScript riche et puissante.
Quelques versions de Bootstrap :
- Bootstrap 5.1 (dernière version) : [Link]
- Bootstrap 4 :
o [Link]
o [Link]
- Bootstrap 3 :
o [Link]
o [Link]
Il y a deux méthodes pour inclure Bootstrap (CSS et Javascript) dans une page HTML :
- Télécharger Bootstrap et inclure les fichiers téléchargés
- Inclure les fichiers Bootstrap à partir des liens externes
Exemple d’inclusion de Bootstrap 5 à partir de liens externes :
<!DOCTYPE html>
<html>
<head>
<title>Développement WEB</title>
<!-- Bootstrap core CSS -->
<link rel="stylesheet" href="[Link]
[Link]">
<!-- Bootstrap javascript -->
<script src="[Link]
[Link]"></script>
</head>
<body>
<h1>Inclure les fichiers Bootstrap à partir des liens externes</h1>
</body>
</html>
6
Le langage PHP
Une page php porte l'extension « .php ». Une page PHP peut être entièrement programmée en PHP ou
mélangée avec du code html. PHP est un langage qui apparaît à n'importe quel endroit de la page HTML.
Pour ça on le place dans des balises particulières : <?php et ?>. On écrit donc une page HTML dans
laquelle on intègre du code PHP.
Fichier PHP : Le code HTML généré sera le suivant :
<html> <html>
<head> <head>
<title>Titre</title> <title>Titre</title>
</head> </head>
<body> <body>
<?php Hello World !
echo "Hello World !"; </body>
?> </html>
</body>
</html>
L'utilisation de balises pour l'intégration de code dans une page web est très souple et permet de
mélanger facilement du code PHP avec du code HTML :
<?php
if ( $expression ) {
?>
<strong>Ceci est vrai.</strong>
<?php
} else {
?>
<strong>Ceci est faux.</strong>
<?php
}
?>
Déclarer une variable
Une variable commence par un dollar « $ » suivi d'un nom de variable. Les variables ne sont pas typées
au moment de leur création. Attention PHP est sensible à la casse ($var et $Var sont deux variables
différentes). Les règles à respecter :
- Une variable peut commencer par une lettre
- Une variable peut commencer par un tiret bas (underscore) « _ »
- Une variable ne doit pas commencer par un chiffre.
7
// Déclaration et règles
$var=1; // $var est à 1
$Var=2; // $Var est à 2
$_toto='Salut'; // Ok
$3petits=5; // Invalide : commence par un chiffre
Le type d’une variable peut changer à tout moment :
// Déclaration et transtypage
$var='2'; // Une chaîne 2
$var+=1; // $var est maintenant un entier 3
$var=$var+0.3; // $var est maintenant un réel de type double 3.3
$var=5 + "3 mots"; // $var est un entier qui vaut 8
Les fonctions
On peut passer 0 ou plusieurs arguments de différents types à une fonction. Une fonction peut ne pas
retourner un résultat, ou retourner n’importe quel type de résultat (variable simple, tableau, objet, etc.)
avec le mot clé « return ». Une fonction a la syntaxe suivante :
function fonction_php ($arg1, $arg2, ..., $argn) {
// instructions
return $valeur;
}
Exemple :
function somme ($arg1, $arg2) {
$valeur = $arg1 + $arg2;
return $valeur;
}
$s = somme(4, 2);
echo $s; // affiche 6
Par défaut, les variables sont passées par copie (la modification de la valeur d’un argument à l’intérieur
de la fonction ne change pas la valeur de la variable passée en argument). Exemple :
function fonction1 ($var) {
$var += 2;
}
$age = 20;
fonction1($age);
echo $age; // affiche 20 et non pas 22
8
Il est possible de passer des arguments par référence. On peut donc changer leurs valeurs à l’intérieur
de la fonction. Pour passer des arguments par référence, il faut ajouter « & » devant l’argument.
Exemple :
function fonction1 (&$var) {
$var += 2;
}
$age = 20;
fonction1($age);
echo $age; // affiche 22
Portée des variables
La portée d'une variable déclarée dans un script et hors d'une fonction est globale mais par défaut sa
portée est limitée au script (fichier) courant, ainsi qu'aux scripts éventuellement inclus (include,
require). Elle n'est pas accessible dans les fonctions ou d'autres scripts non-inclus.
Exemple :
$var = 5;
function ma_fonction () {
echo $var; // erreur : Undefined variable
}
ma_fonction();
Pour accéder à une variable globale dans une fonction, il faut utiliser le mot-clé « global ».
$var = 5;
function ma_fonction2() {
global $var; // on récupère la variable globale
$var *= 2;
}
ma_fonction2();
echo $var; // affiche 10
Une variable définit à l’intérieur d’une fonction est une variable locale, et ne peut pas être utilisée en
dehors de la fonction.
9
Types de variables
Booléens
Un booléen peut prendre deux valeurs TRUE ou FALSE. Les deux constantes TRUE et FALSE peuvent être
utilisées sans aucune distinction de casse (pas de différences entre les majuscules et les minuscules).
$var=FALSE; // FALSE, False, false, ...
$var2=True; // TRUE, True, true, ...
Chaînes de caractères
Une chaîne de caractères peut être entourée par des guillemets simples '...' ou par des guillemets
doubles "...". Parmi les séquences qu’on peut utiliser avec les guillemets doubles on trouve :
\n Nouvelle ligne
\t Tabulation
\\ Antislash
\" Guillemets doubles
Avec les guillemets doubles, n'importe quelle variable peut être affichée dans une chaîne. Exemple :
$age = 20;
//affiche l'age de cet utilisateur est 20 ans
echo "l'age de cet utilisateur est $age ans";
On peut concaténer deux chaînes avec l'opérateur point « . ». On peut ajouter du texte à une chaîne
avec l'opérateur point égal « .= ». Exemple :
$nom = "Ali";
$str = "Le nom ";
$str .= "de cet utilisateur est ";
$str2 = $str . $nom;
echo $str2; //Le nom de cet utilisateur est Ali
Les tableaux
Un tableau PHP est une association ordonnée qui fait correspondre des valeurs à des clés. Les tableaux
sont très souples et peuvent contenir différents types de valeurs simultanément. Une valeur d’un
tableau peut être elle-même un tableau.
Un tableau est créé avec la fonction array() qui prend comme arguments des paires « key => value »
séparées par des virgules. La clé peut être soit un entier soit du texte. Si la clé est absente alors c'est la
dernière clé entière plus 1 qui est choisie. Si c'est la première, c'est 0 zéro.
On accède aux éléments d'un tableau à l'aide des crochets « [ et ] ». On place entre ces crochets la clé
entière ou la chaîne.
10
$tab=array("a"=>12, "nom"=>"ali", "client", 17, 4=>5, "validation");
//$tab["a"] => 12
//$tab["nom"] => ali
//$tab[0] => client
//$tab[1] => 17
//$tab[4] => 5
//$tab[5] => validation
L'utilisation de la fonction array() n'est pas obligatoire et on peut déclarer un tableau à la volée.
Exemple :
$tab2[1]=2;
$tab2[]=6; // equivaut $tab2[2]=6
$tab2["test"]='Ma chaîne';
//$tab2[1] => 2
//$tab2[2] => 6
//$tab2['test'] => Ma chaîne
On peut utiliser la fonction foreach() pour afficher et/ou modifier le contenu d’un tableau. Exemple :
$tab = array(1 => 'un', 2 => 'deux', 3 => 'trois');
foreach($tab as $valeur) {
echo "$valeur <br>"; // affiche un deux trois
}
foreach($tab as $cle => $valeur) {
echo "$cle => $valeur <br>"; // 1 => un, 2 => deux, 3 => trois
}
Inclusion des fichiers
L’inclusion d’un fichier (php ou non) à partir d’un autre fichier php est possible en utilisant les
instructions suivantes :
- include : inclut et exécute le fichier spécifié en argument. Au cas d’échec, elle génère une alerte
(E_WARNING) et termine l’exécution du programme.
- require : inclut et exécute le fichier spécifié en argument. Au cas d’échec, elle génère une erreur
(E_COMPILE_ERROR) et arrête le programme.
- include_once : similaire à « include » mais inclut le fichier une seule fois.
- require_once : similaire à « require » mais inclut le fichier une seule fois.
L’inclusion des fichiers est très utile pour
- utiliser le même template avec plusieurs pages sans répéter le code HTML dans chaque fichier
- utiliser les fonctions et les classes définies dans d’autres fichiers
11
Exemple :
<?php
include "[Link]";
?>
<p>Contenu de page</p>
<?php
include "[Link]";
?>
Corriger l’erreur dans l’exemple suivant :
Fichier [Link] : Fichier [Link] :
<html>
<head>
<title>
<?php
echo $title; <?php
?> include "[Link]";
</title> ?>
</head>
<body> <p>Contenu de page</p>
<?php
Fichier [Link] : include "[Link]";
?>
</body>
</html>
La programmation objet
Une classe est un ensemble de variables et de fonctions (méthodes). Cet ensemble forme les membres
ou les propriétés de l'objet. Une classe est définie en utilisant le mot-clé « class » :
class Personne {
//déclaration des variables et des fonctions
}
La visibilité d’une variable ou d’une fonction indique à partir d’où on peut y accéder. Il y a 3 types de
visibilité : public, protected et private.
12
Accès public protected private
Dans la classe elle-même oui oui oui
Depuis une classe dérivée oui oui
Depuis l'extérieur oui
Une variable définie dans la classe est une variable globale, et doit commencer par un mot-clé de
visibilité (public, protected et private). Elle peut commencer aussi par le mot-clé « var » et dans ce cas
elle est considérée comme publique.
Il est possible d'initialiser les variables au moment de la déclaration. Pour accéder à une variable globale
à l’intérieur d’une classe, on utilise le mot-clé « this » et « -> ». Dans ce cas, on place « $ » devant
« this » et non pas devant la variable.
class Etudiant {
private $nom;
private $prenom;
private $formation = 'ISI1';
public function setNomPrenom($nom, $prenom) {
$this->nom = $nom;
$this->prenom = $prenom;
}
public function setFormation($formation) {
$this->formation = $formation;
}
public function getInfo() {
$info = "nom = " . $this->nom .
", prenom = " . $this->prenom .
", formation = " . $this->formation;
return $info;
}
}
Création d'un objet
Pour créer un objet on utilise le mot-clé « new ».
$et = new Etudiant;
$et->setNomPrenom("Abid", "Ahmed");
echo $et->getInfo(); //nom = Abid, prenom = Ahmed, formation = ISI1
Constructeur
Le constructeur en PHP est une fonction qui porte le même nom que la classe. Si aucun constructeur
n’est définit, c’est le constructeur par défaut qui est appelé.
13
class Personne {
private $nom;
public function Personne($nom) {
$this->nom = $nom;
}
}
$p = new Personne("ali");
La fonction « __construct() » permet aussi de définir le constructeur de la classe (voir :
[Link] ). Cette fonction commence par deux
underscores.
Namespace
L’espace de nommage permet d’organiser le code source et de créer des classes dans des espaces de
nommage bien définies.
La déclaration d’un espace de nommage doit être la première instruction du fichier php. Exemple :
namespace controller;
Utilisation de l’espace de nommage :
Fichier [Link] : <?php
namespace project1;
<html>
<head> class User {
<title> private $title = 'ISI1';
<?php
include '[Link]'; public function getTitle() {
use project1\User; return $ title;
$user = new User; }
$title = $user->getTitle(); }
echo $title;
?> ?>
</title>
</head>
<body>
<p>Utilisation des Namespaces</p>
</body>
</html>
14
Framework Laravel
Introduction
Un framework est un ensemble de composants logiciel (classes, fonctions, etc.) prêt à l’emploi. L’utilité
d’un framework est d’éviter de passer du temps à développer ce qui a déjà été fait. Par exemple, pour
vérifier si les données d’un formulaire sont saisies correctement, on utilise un composant de validation
existant. Egalement, pour faire le routage dans une application web, on prend un composant de routage
prêt et on l’utilise.
Laravel est un Framework PHP « open source » qui a fait son apparition en 2011 et qui évolue
rapidement. Il fait le regroupement de plusieurs framework existants et définit aussi des nouveaux
composants. Par exemple, Laravel utilise plusieurs fonctionnalités de Symphony, SwiftMailer et d’autres
librairies.
Les différentes versions de Laravel sont (source : [Link]/wiki/Laravel) :
Version Date d’apparition Version minimale nécessaire de PHP
1.0 Juin 2011
2.0 Septembre 2011
3.0 Février 2012
3.1 Mars 2012
3.2 Mai 2012
4.0 Mai 2013 ≥ 5.3.0
4.1 Décembre 2013 ≥ 5.3.0
4.2 Juin 2014 ≥ 5.4.0
5.0 Février 2015 ≥ 5.4.0
5.1 Juin 2015 ≥ 5.5.9
5.2 Décembre 2015 ≥ 5.5.9
5.3 Aout 2016 ≥ 5.6.4
5.4 Janvier 2017 ≥ 5.6.4
5.5 Aout 2017
5.6 Février 2018 ≥ 7.1.3
5.7 Septembre 2018 ≥ 7.1.3
5.8 Février 2019 ≥ 7.1.3
6 3 Septembre 2019 7.2.0 – 8.0
7 3 Mars 2020 7.2.5 – 8.0
8 8 Septembre 2020
9 8 Février 2022 8.0 – 8.1
10 7 Février 2023 8.0 – 8.1
15
Installation
Il y a plusieurs versions de Laravel, et chaque version a ses propres besoins. Par exemple, la version 5.4
nécessite au minimum la version PHP 5.6.4. Pour trouver les différents besoins d’une version en
particulier de Laravel, il faut consulter le site web de Laravel accessible sur l’adresse suivante :
[Link]
Ensuite, aller sur « Documentation » et sélectionner la version de Laravel (exemple version « 5.5 »)
Question : trouver la version PHP minimale nécessaire pour Laravel 5.5 et pour Laravel 9.x
Il faut aller à « Getting Started > Installation » dans le cas de Laravel 5.5
Il faut aller à « Prologue > Release Notes » dans le cas de Laravel 8.x
Il est possible d’utiliser Laravel avec plusieurs serveurs (WAMP, XAMPP, etc.). Laravel utilise des
composants provenant d’autres frameworks. Ces composants ne sont pas incorporés directement dans
Laravel et doivent être téléchargés. La méthode classique consiste à télécharger Laravel et tous les
frameworks dont il a besoin (tout en vérifiant la compatibilité des versions). Cette méthode n’est pas
pratique !
Solution : on utilise l’outil « Composer »
« Composer » est un gestionnaire de dépendances qui permet de télécharger Laravel et toutes ses
dépendances. Il permet aussi de télécharger d’autres projets de tous types. Il est possible de télécharger
cet outil à partir de l’url suivante : [Link]
Lors de l’installation de « Composer », il faut lui indiquer le chemin vers « [Link] »
Création d’une nouvelle application Laravel
Pour créer une nouvelle application Laravel nommée « forum » dans le dossier « www » de
WampServer (ou dans le dossier « htdocs » de XAMPP), en utilisant Composer, il faut :
1) Lancer un terminal
2) Se déplacer dans le dossier « www » de WampServer (ou dans le dossier « htdocs » de XAMPP)
3) Taper la commande suivante :
composer create-project laravel/laravel forum-app
16
Remarque : La commande précédente installe la dernière version de Laravel qui soit compatible avec la
version installée de PHP, dans le dossier « www/forum » (ou « htdocs/forum »).
Pour installer une version en particulier de Laravel en utilisant Composer, on ajoute la version en
paramètre. L’exemple suivant permet d’installer Laravel 8.x dans le dossier « blog » :
composer create-project laravel/laravel forum-app "8.*"
Exercice : Créer une nouvelle application Laravel 9.x nommée « laravel-app » sous le dossier « www »
de wamp (ou « htdocs » de xampp).
Organisation d’une application Laravel
L’organisation par défaut d’une application peut changer selon la version Laravel. Cette organisation a le
but de simplifier le développement d’une application web, mais il est possible de la modifier selon le
besoin.
Cas de Laravel 9.x (voir : [Link]/docs/9.x/structure)
- Dossier « routes » : contient toutes les routes vers les différentes pages de l’application. Ce
dossier contient par défaut les fichiers « [Link] », « [Link] », « [Link] » et
« [Link] ». Pour une application simple, les différentes routes sont généralement définies
dans le fichier « [Link] ».
- Dossier « resources » : contient les 3 dossiers suivants :
o views : contient les différentes vues (pages web)
o lang : contient les fichiers de langues
o assets : contient des fichiers js, etc.
- Dossier « public » : contient le fichier « [Link] » qui est le point d’entrée pour toutes les
requêtes venant à l’application. Ce dossier peut contenir des images, des fichiers js et css, etc.
o Quelle est l’utilité du fichier « .htaccess » ?
Questions :
1) Quelle est la différence entre la structure de Laravel 5.5 et celle de Laravel 9.x ?
2) Est-ce que le contenu du dossier « routes » change dans la version 9.x ?
3) Est-ce que le contenu du dossier « resources » change dans la version 9.x ?
Facades et Helpers
17
Voir : « [Link]/docs/9.x/facades » et « [Link]/docs/9.x/helpers »
Laravel propose plusieurs façades (alias) pour simplifier la programmation de l’application.
L’usage d’une façade est insensible à la casse, et les exemples suivants sont corrects et identique :
return view::make('accueil');
return View::make('accueil');
return VIEW::make('accueil');
Pour utiliser des nouvelles façades, il faut les déclarer dans « config/[Link] » sous la clé « aliases ».
Par exemple, après l’ajout du composant « html » on peut ajouter les deux façades suivantes :
'aliases' => [
...
'Form' => Collective\Html\FormFacade::class,
'Html' => Collective\Html\HtmlFacade::class,
...
],
Laravel définit aussi les « helpers » qui permettent de simplifier davantage la syntaxe. Plusieurs
« helpers » réalisent les mêmes fonctionnalités des façades mais avec une syntaxe simplifiée. Par
exemple, les deux instructions suivantes sont identiques :
Retourner une vue en utilisant une façade : Retourner une vue en utilisant un helper :
return view::make('accueil'); return view('accueil');
Remarque : tout comme les façades, les helpers sont aussi insensibles à la casse !
Les routes
Voir « [Link]/docs/9.x/routing »
Lorsque la requête arrive au fichier « public/[Link] », l’application Laravel est créée et configurée.
Ensuite, les fichiers du dossier « routes » (y compris « [Link] ») sont chargés. Le fichier « [Link] »
définit les routes vers les différentes pages web.
A l’installation de Laravel, il y a une seule route dans Le fichier « [Link] » qui correspond à l’url de
base :
Route::get('/', function () {
return view('welcome');
});
18
Si :
- la requête est reçu avec la méthode « get » avec ou sans paramètres (Route::get), et
- la requête est envoyée à l’url de base (/)
Alors : retourner la vue « welcome » qui se trouve sous « resources/views » dans un fichier nommé
« [Link] » ou « [Link] »
Une route en Laravel accepte un URI et une fonction permettant de produire une réponse. Les
différentes routes sont définies dans le dossier « routes », et principalement dans le fichier « [Link] »
de ce dossier. Le routeur permet d’enregistrer des routes qui répondent aux différentes méthodes
HTML (GET, POST, etc.). Les fonctions du routeur sont :
Route::get($uri, $callback);
Route::post($uri, $callback);
Route::put($uri, $callback);
Route::patch($uri, $callback);
Route::delete($uri, $callback);
Route::options($uri, $callback);
Exemples d’URI :
- '/' : URI racine de l’application (emplacement du fichier « [Link] » de Laravel). Exemple :
« [Link] », « localhost » et « localhost/forum/public ».
- '/home' ou 'home' : chemin relatif à ajouter à l’URI racine. Exemple :
« [Link]/home », « localhost/home »,
« localhost/forum/public/home ».
- '/home/account' ou 'home/account'
Exercice :
1) Dans l’application « laravel-app », ajouter une route pour l’url « route1 » accessible par la
méthode GET dans fichier « [Link] » permettant d’afficher le texte « nouvelle route ».
2) Créer la vue « [Link] » sous « resources/views » avec le contenu suivant :
<!doctype html>
<html>
<body>
<h1>bonjour à tous</h1>
<p>Il est <?php echo date("H:i:s") ?></p>
</body>
</html>
19
3) Ajouter une route pour l’url « route2 » accessible par la méthode GET dans fichier « [Link] »
permettant d’afficher la vue « [Link] »
4) Ajouter une route pour l’url « route3 » accessible par la méthode POST dans fichier « [Link] »
permettant d’afficher le texte « troisième route ». Est-il possible d’accéder à cette route ?
Pour enregistrer une route capable de répondre à un ensemble de méthodes HTML, on utilise la
fonction « match ». On peut aussi utiliser la fonction « any » pour répondre à toutes les méthodes
HTML. Exemple :
Route::match(['get', 'post'], 'add', function () {
return "Ajouter"; //afficher "Ajouter"
});
Route::any('cart', function () {
return "Panier"; //afficher "Ajouter"
});
Protection CSRF :
Tout formulaire HTML utilisant la méthode HTML « post » doit inclure un jeton CSRF. Sinon, la requête
sera rejetée (pour plus d’information sur la protection CSRF, voir lien : « [Link]/docs/9.x/csrf »).
La fonction PHP « csrf_field() » permet de retourner une chaine de caractères qui représente un
champ contenant le jeton CSRF. On peut ajouter ce champ dans un formulaire HTML.
Exemple de résultat de « csrf_field() » :
<input type="hidden" name="_token" value="eQLnTzhL3c9aX0PjNy27xY3Kcay0ufgxWUOgkhU4">
Exemple d’usage de « csrf_field() » :
<form method="POST" action="/add">
<?php echo csrf_field() ?>
...
</form>
Les vues
Voir lien : « [Link]/docs/9.x/views »
Les vues contiennent le code HTML et sont sauvegardées dans le dossier « resources/views ». Pour
retourner une vue, on peut utiliser le helper « view » ou bien les méthodes de la façade « view ».
Exemple « resources/views/[Link] » :
20
<!doctype html>
<html>
<body>
<h1>bonjour <?php echo $name ?></h1>
<p>Il est <?php echo $date ?></p>
</body>
</html>
La vue « [Link] » nécessite les deux variables « $name » et « $date » qui ne sont pas initialisées
dans le fichier. Retourner cette vue avec le code suivant génère des erreurs (Undefined variable:
name/date) :
Route::get('accueil', function () {
return view('accueil');
});
Pour corriger ces erreurs, il faut passer les variables « $name » et « $date » dans un tableau indexé (les
clés représentent les noms des variables) à la vue. Ce tableau est le 2eme paramètre du helper « view »
(le premier paramètre est la vue).
Exemple 1 :
Route::get('accueil', function () {
$n = "Ali";
$d = date("H:i:s");
$data = ['name' => $n, 'date' => $d];
return view('accueil', $data);
});
Exemple 2 :
Route::get('accueil', function () {
return view('accueil', ['name' => "Ali", 'date' => date("H:i:s")]);
});
En général, il est possible de passer un nombre indéfini de variables à une vue en utilisant un tableau
indexé. Ensuite, la vue peut utiliser ces variables.
Les vues peuvent être organisées dans des dossiers à l’intérieur de « resources/views ». Pour accéder à
ces vues avec le helper « view », il faut lui donner le chemin d’une vue en séparant les noms des
dossiers et de la vue avec des points.
Exemple :
//retourner la vue resources/views/admin/[Link]
return view('[Link]');
21
Pour vérifier l’existence d’une vue, on peut utiliser la méthode « exists » de la façade « view » comme
suit :
if (View::exists('[Link]')) {
//
}
Les contrôleurs
Voir le lien « [Link]/docs/9.x/controllers »
Au lieu de définir toutes les instructions dans le fichier « routes/[Link] » dans une fonction de rappel,
il est possible d’utiliser des contrôleurs. Les contrôleurs sont stockés sous « app/Http/Controllers ».
L’exemple suivant est un contrôleur nommé « HomeController » définit dans le fichier
« [Link] » du dossier « app/Http/Controllers » :
<?php
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
class HomeController extends Controller
{
public function showHome(Request $request)
{
$n = "User";
$d = date("H:i:s");
$data = ['name' => $n, 'date' => $d];
return view('accueil', $data);
}
public function showInfo()
{
$info = "Laravel est un Framework PHP simple et puissant. ";
return $info;
}
}
Après la création de la classe « HomeController », on peut définir des routes vers les méthodes de ce
contrôleur dans le fichier « routes/[Link] » comme suit :
Route::get('/ctrl/home', 'HomeController@showHome');
Route::get('/ctrl/info', 'HomeController@showInfo');
Injection de dépendance
22
Le « service container » de Laravel est utilisé pour résoudre tous les contrôleurs. Il est possible
d’indiquer tous les paramètres utilisés par les méthodes et les constructeurs des contrôleurs. Ces
paramètres seront automatiquement injectés dans les méthodes et les constructeurs. Un usage typique
de l’injection de dépendance consiste à injecter l’objet « Illuminate\Http\Request » dans les méthodes
du contrôleur (voir la méthode showHome() de la classe HomeController).
Exercice :
1) Dans l’application « laravel-app », créer le contrôleur « ContactController » avec les deux
méthodes suivantes :
a. showView : permet de retourner la vue « [Link] » (disponible dans les templates)
b. addContact : permet de lire les données du formulaire de contact à partir du tableau
$_POST et de retourner la vue « [Link] » suivante :
<!doctype html>
<html>
<body>
<h1>Nous avons bien reçu votre demande :</h1>
<p>Nom : <?php echo $name ?></p>
<p>Email : <?php echo $email ?></p>
<p>Téléphone : <?php echo $phone ?></p>
<p>Sujet : <?php echo $subject ?></p>
<p>Message : <?php echo $message ?></p>
</body>
</html>
2) Ajouter une route pour l’url « contact » accessible par la méthode GET dans fichier « [Link] »
permettant d’appeler la méthode « showView » du contrôleur.
3) Ajouter une route pour l’url « contact » accessible par la méthode POST dans fichier « [Link] »
permettant d’appeler la méthode « addContact » du contrôleur. Tester l’envoi d’un formulaire.
4) Ajouter la variable « Request $request » en paramètre de la méthode « addContact » et
utiliser cette variable à la place de $_POST pour lire les données du formulaire. Exemple :
//lien : [Link]
$name = $request->input('name');
Blade
Voir lien : « [Link]/docs/9.x/blade »
Blade est un moteur de template qui simplifier la syntaxe. Pour utiliser la syntaxe Blade dans une vue, il
faut que la vue soit sauvegardée dans un fichier « blade » : le nom de ce fichier se termine par
« .[Link] ». La syntaxe Blade est incompréhensible dans un fichier PHP classique qui n’est pas un
fichier « blade ». Il est possible d’utiliser les balises PHP classiques dans un fichier « blade ».
23
