PHP & Initiation Symfony

2
La 1ère école 100 % dédiée à l'open source
Open Source School est fondée à l'initiative de Smile, leader de
l'intégration et de l'infogérance open source, et de l'EPSI,établissement
privé pionnier de l’enseignement supérieur en informatique.
Dans le cadre du Programme d’Investissements d’Avenir (PIA), le
gouvernement français a décidé de soutenir la création de cette école en
lui attribuant une première aide de 1,4M€ et confirme sa volonté de
soutenir la filière du Logiciel Libre actuellement en plein développement.
Avec une croissance annuelle de plus de 10%, et 4 000
postes vacants chaque année dans le secteur du Logiciel
Libre, OSS entend répondre à la pénurie de compétences du
secteur en mobilisant l’ensemble de l’écosystème et en
proposant la plus vaste offre en matière de formation aux
technologies open source tant en formation initiale qu'en
formation continue.

3
Les formations du plein emploi !
 Formation Continue
Open Source School "Executive Education" est un
organisme de formation qui propose un catalogue de
plus de 200 formations professionnelles et différents
dispositifs de reconversion permettant le retour à
l’emploi (POE) ou une meilleure employabilité pour de
nombreux professionnels de l’informatique.
 Pour vos demandes : formations@opensourceschool.fr
 Formation Initiale
100% logiciels libres et 100% alternance, le cursus Open
Source School s’appuie sur le référentiel des blocs de
compétences de l’EPSI.
Il est sanctionné par un titre de niveau I RNCP, Bac+5.
Le programme est proposé dans 6 campus à Bordeaux,
Lille, Lyon, Montpellier, Nantes, Paris.

PHP & Initiation Symfony
Programme Bachelor
3ème Année Parcours Open Source

OSS – Formation PHP
Licence Creative Commons (CC BY-SA 3.0 FR) Attribution - Partage dans les Mêmes Conditions 3.0 France
PHP
PHP BASICS
Les bases
PHP ADVANCED
Aller plus loin

PHP Basics
 Introduction
 Premiers pas
 Bases du langage

PHP Basics - Intro
 Sources
 PHP en quelques mots
 PHP, ça sert à quoi ?
 PHP, ça peut faire quoi ?

Sources
 http://www.php.net/
Nouveautés, manuel, téléchargement et toutes les
informations à propos de PHP.
 http://fr.wikipedia.org/wiki/Portail:
Programmation_informatique

PHP en quelques mots
PHP est un langage de script
 Open source
 Généraliste bien qu'orienté web
 À la fois simple dans sa prise en main et avancé dans
ses possibilités

A quoi ça ressemble ?
<?php
echo "Hello world";
?>

Et dans une page web ?
<html>
<head>
<title>Exemple</title>
</head>
<body>
<?php
echo "Hello world";
?>
</body>
</html>

PHP Basics - Intro
 Sources
 PHP en quelques mots
 PHP, ça sert à quoi
 PHP, ça peut faire quoi ?

PHP, ça sert à quoi ?
Les utilisations courantes
 Servir dynamiquement des documents sur le web:
– PHP génère
– Le serveur web sert
 Exécuter des tâches en ligne de commande

Servir des documents sur le web
 L’utilisation traditionnelle et la plus courante de PHP
 Doit être couplé à un serveur web tel qu’Apache,
Lighttpd, IIS. . .
 Principalement des pages HTML, mais pas seulement:
images, PDF, XML...

Exécuter des tâches en ligne de commande
 Pour des tâches planifiées/régulières (CRON)
 Pour des opérations lourdes: exports, imports, scripts
de déploiement, transformations de données...

PHP, ça peut faire quoi ?
La liste est longue car:
 Le langage évolue et s’enrichit depuis 20 ans
 De nombreuses extensions existent, pour de multiples
usages

PHP Basics
Premiers pas
 Servir une page web
 Apache / PHP sous linux

Servir une page web
Chemin d’une requête HTTP:

Servir une page web
PHP intervient coté serveur :

Apache/PHP sous Linux
LAMP :
Acronyme de 4 briques constituant un serveur web:
 Linux: une distribution courante (RedHat, Debian...)
 Apache: le serveur HTTP en charge de traiter les requêtes
 MySQL: base de données SQL
 PHP: notre interpréteur de scripts
Chaque brique est peut être remplacée par un équivalent. Pour
plus de simplicité nous utiliserons de préférence la version
”packagée” avec la distribution.

Installation
 Debian / Ubuntu:
– aptitude update
– aptitude install apache2 mysql-server php5 php5-mysql
 RedHat / CentOS:
– yum update
– yum install httpd mysql-server php5 php5-mysql
– service httpd restart
– service mysqld restart

Vérifier le fonctionnement
 Vérifier la version de PHP installée: php -v
 Accéder aux pages web: http://localhost/
 Où sont mes fichiers ? :
– Debian/Ubuntu: /var/www/
– Debian (récentes): /var/www/html/
– RedHat/CentOS: /var/www/html/

Un fichier ”index.php”
<html>
<head>
<title>Exemple</title>
</head>
<body>
<?php
echo "Hello world";
?>
</body>
</html>

PHP Basics
Bases du langage
 Syntaxe
 Les types de données
 Les variables
 Les constantes
 Les expressions
 Les reférences
 Les opérateurs
 Les structures de contrôle
 Les fonctions
 Les exceptions

PHP Basics
Bases du langage
 Syntaxe
 Les variables
 Les constantes
 Les expressions
 Les références
 Les opérateurs
 Les fonctions

Syntaxe
Lors du traitement d’un script PHP recherche les balises ”<?php” et ”?>” qui
délimitent le code à interpréter.
Ce qui est en dehors de ces balises n’est pas interprété par PHP.
La balise fermante est optionnelle, à condition qu’il n’y ait que du PHP jusqu’à la
fin du fichier.
D’autres tags existent mais sont déconseillés:
 <? ?>
connu sous l’appellation Short Tags
 <% %>
connu sous l’appellation ASP Tags
 <script language="php"> </script>

Syntaxe
Les instructions sont séparées par ”;” (point virgule).
Celui-ci est optionnel s’il précède une balise fermante ”?>”.

Syntaxe
Exemples de code valide
<?php
echo 'Hello world';
?>
<?php
echo 'La balise fermante
implique le point virgule' ?>
<?php
echo 'La balise fermante est optionnelle car
le fichier se termine sur du PHP';

Syntaxe
Exemples de code invalide
<?php
echo 'La balise fermante est absente
et aucun point virgule ne
vient clore l’instruction'
<?php
echo 'La balise fermante est absente
mais du HTML se trouve apres' ;
<p>Hello</p>
</html>

Syntaxe
Les commentaires
<?php
echo 'Hello' ; // Commentaire sur une ligne
/* Commentaire sur
plusieurs
lignes
*/
echo 'Hello' ; # Commentaire sur une ligne
?>

Syntaxe
Il n’est pas possible d’inclure un bloc de commentaires dans un
autre bloc de commentaires:
<?php
/* <== Ouverture d’un bloc de commentaire
echo ’Hello’; Cette ligne n’est pas interpretee
// Ce commentaire fonctionne aussi
echo ’world’; /* Ce second bloc de commentaires
va poser probleme a
cause de la fermeture */
*/
?>

Syntaxe
Guillemets simples ou doubles
<?php
$a = 'Bonjour' ;
$b = "monde" ;
echo "$a $b" ; // Affiche Bonjour monde
echo '$a $b' ; // Affiche $a $b
?>

Syntaxe
Guillemets simples ou doubles
 Simples
– Le contenu de la chaîne est retourné tel quel
 Doubles
– Le contenu de la chaîne est interprété
– Les variables sont remplacées
– Les caractères spéciaux sont remplacés (n, r...)
http://www.php.net/manual/fr/language.types.string.php#language.types.string.parsing

PHP Basics
Bases du langage
 Syntaxe
 Les variables
 Les constantes
 Les expressions
 Les reférences
 Les opérateurs
 Les fonctions

Les types de données
PHP propose 8 types de données:
 Scalaires
– Booléen: boolean
– Entier: integer
– Float: integer
– Chaîne: string
 Composés
– Tableau: array
– Objet: object
 Autres (types dits ”spéciaux”)
– Ressources: resource ( variable spéciale, contenant une référence vers une
ressource externe )
– Nul: NULL

Exemples:
<?php
$a = TRUE ; // un booléen
$b = "ma chaîne" ; // une chaîne de caractères
$d = 42 ; // un entier
$e = [4, 8, 15, 16, 23, 42]; // un tableau
echo gettype($a) ; // affiche : boolean
echo gettype($b) ; // affiche : string
echo gettype($c) ; // affiche : NULL
echo gettype($d) ; // affiche : integer
echo gettype($e) ; // affiche : array
?>

PHP n’impose pas de type lors de la déclaration des variables.
Celui-ci est déterminé par son contexte.
Le type d’une variable peut évoluer durant l’exécution d’un script.
Exemples:
<?php
$a = '0' ; // une chaîne de caractères
$a = $a + 42 ; // un entier
$a = $a + 4.2 ; // un float
?>

Les conversions interviennent automatiquement selon le type des
opérandes (les ”valeurs”).
Il est cependant possible de modifier manuellement cette
interprétation (cast).
Exemples:
<?php
$a = 1 ; // un entier
$a = (boolean)$a; // un booléen
?>
Il est important de noter qu’ici la valeur et le type de $a
restent inchangés. Seul l’interprétation de sa valeur a été
influencée par le cast.

Préfixes de modification de types:
 (bool), (boolean) : modification en boolean
 (int), (integer) : modification en integer
 (float), (double), (real) : modification en float
 (string) : modification en string
 (array) : modification en array
 (object) : modification en object
 (unset) : modification en NULL (PHP 5)
 (binary) : modification en binaire (PHP 5.2.1)

Certains cas peuvent ếtre difficiles à prévoir pour un néophyte. En
particulier quand des chaînes sont évaluées sous forme de valeurs
numériques.
Exemples:
<?php
$a = 42 ; // un entier
$a = $a + '2 souris' ; // un entier
$a = 42 + '2.2 souris' ; // un float (44.2)
$a = 42 + '2e2 souris' ; // un float (242)
$a = '2e2 souris' + 42; // un float (242)
?>

Logique de conversion vers un ”numérique”:
1. Définir le type: entier ou float ?
1. Si la chaîne de caractères ne contient aucun ’.’, ’e’ ou ’E’, et que la valeur
numérique est dans l’intervalle de représentation des entiers alors la chaîne de
caractères sera transformée en entier.
2. Sinon elle est interprétée comme un décimal (float).
2. La valeur est déterminée en fonction de la première partie de la chaîne
1. Si cette première partie est une valeur numérique alors elle est utilisée
2. Sinon la valeur sera 0

Les variables
Une variable commence par un $ (dollar) directement suivi du nom de la variable.
Le nom de la variable est sensible à la casse.
Certaines règles sont imposées:
 Le nom doit commencer par une lettre ou un _ (underscore).
 Le nom peut être composé de lettre, underscore, chiffres, valeurs ASCII de 127 à 255.
 $this est un nom réservé

Les variables
Exemples:
<?php
$aaaa = 42 ; // valide
$_4aa = 42 ; // valide
$aäaa = 42 ; // valide car ä est le caractère ASCII 0228
$4aaa = 42 ; // invalide : commence par un chiffre
?>

Les variables
Doit-on initialiser les variables ?
En PHP il n’est pas nécessaire d’initialiser une variable...
... mais cela reste une bonne pratique !
Selon son utilisation une variable non initialisée retournera:
 boolean: FALSE
 integer, float: 0
 string: ”” (chaîne vide)
 array: [] (tableau vide)
Il est possible de vérifier si une variable est initialisée grâce à la fonction isset().

Les variables
Certaines variables sont prédéfinies par PHP.
Elles contiennent des informations sur l’environnement et le contexte courant.
Autrement dit: le serveur, les paramètres, la configuration…
La plupart d’entre elles sont des ”super globales”: elles sont disponibles à tout instant de
l’exécution du script.

Les variables
Liste des variables pré-définies:
 $GLOBALS : Référence toutes les variables disponibles dans un contexte global
 $SERVER : Variables de serveur et d’exécution
 $GET : Variables HTTP GET
 $POST : Variables HTTP POST
 $FILES : Variables de téléchargement de fichier
 $REQUEST : Variables de requête HTTP
 $SESSION : Variables de session
 $ENV : Variables d’environnement
 $COOKIE : Cookies HTTP$
 $HTTP RAW POST DATA : Données POST brutes
 $php errormsg : Le dernier message d’erreur
 $http response header : En-tếtes de réponse HTTP
 $argc : Le nombre d’arguments passés au script
 $argv : Tableau d’arguments passés au script

Les variables
Chaque variable possède une portée (scope).
Celle-ci change selon le contexte de déclaration:
 sur le script complet
 dans une fonction
 dans une classe

Les variables
Exemple 1/2:
<?php
$a = 42 ; // scope global
function mafunction()
{
echo $a; // scope local de la fonction
}
mafonction(); // résultat ?
?>

Les variables
Exemple 2/2:
<?php
$a = 42; // scope global
{
$a = 'hello' ;
echo $a; // scope local de la fonction
}
echo $a; // résultat ?
?>

Les variables
Il est possible de modifier la portée d’une variable
 Grâce au mot clé ”global”
 Grâce à la variable $GLOBALS
 Grâce au mot clé ”static”

Les variables
Utilisation du mot clé ”global”:
<?php
{
global $a; // modifie le scope de la variable
echo $a;
}
?>
L’instruction ”global” modifie le scope de la variable $a pour la fonction courante.
Désormais toute opération sur la variable $a réalisée dans la fonction modifie la variable
du scope global.

Les variables
Utilisation de la variable $GLOBALS:
<?php
{
echo $_GLOBALS['a'];
// Cette variable contient des references
// vers toutes les variables du scope global
}
?>
L’instruction de la variable $_GLOBALS[’a’] réalisée dans la fonction utilise la variable $a
du scope global.

Les variables
Utilisation du mot clé ”static” 1/2:
<?php
{
$a = 0;
echo $a;
$a++;
}
?>

Les variables
Utilisation du mot clé ”static” 2/2: Une variable statique garde une portée locale, mais
elle ne perd pas sa valeur lorsque le script appelle la fonction.
<?php
{
static $a = 0;
echo $a;
$a++;
}
?>
La variable $a est initialisée uniquement lors du premier appel à la fonction.

Les variables
Nommage dynamique d’une variable
<?php
$a = 'bonjour' ;
$$a = 'monde' ;
echo "$a ${$a}"; // Affiche ’bonjour monde’
echo "$a $bonjour"; // Même résultat
echo ${strtolower('A')}; // Même résultat
?>
La chaîne située entre crochets est interprétée pour fabriquer le nom de la variable.

Les constantes
Une constante est un identifiant qui représente une valeur simple ne pouvant être
modifiée durant l’exécution.
Le nom de la constante est sensible à la casse, par convention elle sera toujours en
majuscule.
Certaines règles sont imposées:
 Les mêmes que pour une variable.
 Le nom doit commencer par une lettre ou un _ (underscore).
 Le nom peut être composé de lettres, underscores, chiffres, valeurs ASCII de 127 à 255.

Les constantes
Exemples:
<?php
define('AAAA', 42) ; // valide
define('_4AA', 42) ; // valide
define('4AAA', 42) ; // invalide(commence par un chiffre)
define('aaaa', 42) ; // valide, mais déconseillé
?>

Les constantes
Comment définir une constante :
<?php
define('MACONSTANTE', 42) ;
// a partir de php 5.3
Const MACONSTANTE = 42
// a partir de php 5.6
const AUTRE_CONSTANTE = MACONSTANTE . 'souris' ;
?>

Les constantes
PHP définit plusieurs constantes ”magiques”:
 __LINE__ : La ligne courante dans le fichier
 __FILE__ : Le chemin complet du fichier courant
 __DIR__ : Le dossier du fichier courant (PHP 5.3)
 __FUNCTION__ : Le nom de la fonction.
 __CLASS__ : Le nom de la classe courante
 __METHOD__ : Le nom de la méthode courante
 __NAMESPACE__ : Le nom de l'espace de noms courant
 __TRAIT__ : Le nom du trait déclaré (PHP 5.4)

Les expressions
Une expression peut être définie comme ”ce qui a une valeur”.
Une variable est une expression, tout comme une constante ou une fonction.
Dans le cas d’une fonction cette valeur évolue généralement d’un appel à l’autre.
La plupart des opérations sont elles-mêmes des expressions.
C’est avant tout un point de vocabulaire.

Les expressions
Nommage dynamique d’une variable
<?php
$a = 'bonjour';
// $a est desormais une expression de ’bonjour’
$b = $a;
// fonctionne car $a est une expression
// (£a = ’bonjour’) est aussi une expression
// De ce fait:
$b = $a = 'bonjour';
// est tout à fait valide
?>

Les références
Une référence permet d’accéder à une variable à partir de plusieurs noms.
La référence est symbolisée par un &.
Elle est souvent confondue avec un pointeur (équivalence C), il ne s’agit pas ici d’une
adresse en mémoire. Il s’agit d’un alias.
L’analogie informatique la plus proche est le lien symbolique UNIX.
La destruction d’une référence ne détruit pas son contenu tant qu’au moins une référence
existe.

Les références
Il y a 3 utilisations possibles des références:
 L’assignation par référence
 Le passage par référence
 Le retour par référence

Les références
Assignation par référence
<?php
$a = &$b;
?>
Dans ce cas $a et $b pointent vers le même contenu

Les références
Passage par référence
<?php
$a = 42;
function plusOne(&$number)
{
$number++;
}
echo $a;
plusOne($a);
echo $a;
?>
La variable globale $a et la variable locale $number pointent vers le même contenu.
La variable globale $a est incrémentée de 1.

Les références
Retour par référence
<?php
$a = 42;
$a = 'bonjour';
function &getGoodOne()
{
global $a;
return $a;
}
// Cette fonction va nous aiguiller
$c = &getGoodOne();
// $c pointe vers le meme contenu que $a
?>
Il est possible de faire une référence sur le prototype ou sur l’appel de la fonction.

Les opérateurs
Un opérateur est une fonction spéciale prenant plusieurs expressions en entrée et
retournant une expression.
Par exemple en mathématiques l’opérateur + (addition) prend 2 expressions en entrée et
retourne la somme.
Il existe des opérateurs:
 Unaire, ne prenant qu’une entrée: !, ++ (incrémentation)
 Binaire, 2 entrées: +, -, et la majorité de ce que propose PHP.
 Ternaire, le seul prenant 3 entrées: ?:

Les opérateurs
Ils peuvent être classés par familles:
 opérateurs arithmétiques
 opérateurs sur les bits
 opérateurs de comparaison
 opérateur de contrôle d’erreur
 opérateur d’exécution
 opérateurs d’in/décrémentation
 opérateurs logiques
 opérateur de chaînes
 opérateurs de tableaux
 opérateur de types
 opérateurs d’affectation

Les opérateurs
Opérateurs arithmétiques:
 -$a Négation: Opposé de $a.
 $a + $b Addition: Somme de $a et $b.
 $a - $b Soustraction: Différence de $a et $b.
 $a * $b Multiplication: Produit de $a et $b.
 $a /$b Division: Quotient de $a et $b.
 $a % $b Modulo: Reste de $a divisé par$b.
 $a ** $b Exponentielle: Résultat de l’élévation de $a à la puissance $b (PHP 5.6+)

Les opérateurs
Opérateurs sur les bits :
 $a & $b And (Et)
Les bits à 1 dans $a ET dans $b sont positionnés à 1.
 $a | $b Or (Ou)
Les bits à 1 dans $a OU $b sont positionnés à 1.
 $a ˆ $b Xor (ou exclusif)
Les bits à 1 dans $a OU dans $b mais pas dans les deux sont positionnés à 1.
 ̃ $a Not (Non)
Les bits qui sont à 1 dans $a sont positionnés à 0, et vice-versa.
 $a << $b Décalage à gauche
Décale les bits de $a, $b fois sur la gauche.
 $a >> $b Décalage à droite
Décalage les bits de $a, $b fois par la droite.

Les opérateurs
Opérateurs de comparaison
 $a == $b Egal TRUE si $a est égal à $b.
 $a === $b Identique TRUE si $a est égal à $b et qu’ils sont de même type.
 $a != $b Différent TRUE si $a est différent de $b.
 $a <> $b Différent TRUE si $a est différent de $b.
 $a !== $b Différent TRUE si $a est différent de $b
ou bien s’ils ne sont pas du même type.
 $a < $b Plus petit TRUE si $a est strictement plus petit que $b.
 $a > $b Plus grand TRUE si $a est strictement plus grand que $b.
 $a <= $b Inférieur ou égal TRUE si $a est plus petit ou égal à $b.
 $a >= $b Supérieur ou égal TRUE si $a est plus grand ou égal à $b.

Les opérateurs
Opérateur de contrôle d’erreur:
Cela se résume au symbole @.
Lorsqu’il précède une expression les erreurs éventuelles seront ignorées.
<?php
$a = errorFunc();
$b = @errorFunc();
?>
Le premier appel provoquera une erreur.
Le second appel ne retournera aucune indication.

Les opérateurs
Opérateur d’exécution:
Cela se résume au symbole ‘ (guillement oblique), à ne pas confondre avec le guillemet
simple.
Ce qui est englobé sera interprété comme une commande shell.
<?php
$output = `ls -al`;
echo $output;
?>
La fonction shell exec() est identique à cet appel.

Les opérateurs
Opérateurs d’incrémentation:
 ++ $a Pre-incrémente Incrémente $a de 1, puis retourne $a
 $a++ Post-incrémente Retourne $a, puis incrémente $a de 1
 -- $a Pré-décrémente Décrémente $a de 1, puis retourne $a
 $a – Post-décrémente Retourne $a, puis décrémente $a de 1

Les opérateurs
Opérateurs logiques:
 $a and $b And (Et) TRUE si $a ET $b valent TRUE.
 $a && $b And (Et) TRUE si $a ET $b sont TRUE.
 $a or $b Or (Ou) TRUE si $a OU $b valent TRUE.
 $a || $b Or (Ou) TRUE si $a OU $b est TRUE.
 $a xor $b XOR TRUE si $a OU $b est TRUE, mais pas les deux en même temps.
 ! $a Not (Non) TRUE si $a n’est pas TRUE.

Les opérateurs
Opérateur de chaîne:
Cela se résume au symbole . (point).
Il retourne la concaténation de ses 2 arguments.
<?php
$a = ’bonjour’ . ’ monde’;
echo $a;
// Affiche "bonjour monde"
?>

Les opérateurs
Opérateurs de tableaux 1/2:
 $a + $b Union Union de $a et $b.
 $a == $b Egalité TRUE si $a et $b contiennent les mêmes paires clés/valeurs.
 $a === $b Identique TRUE si $a et $b contiennent
* les mêmes paires clés/valeurs
* dans le même ordre
* et du même type.
 $a != $b Inégalité TRUE si $a n’est pas égal à $b.
 $a <> $b Inégalité TRUE si $a n’est pas égal à $b.
 $a !== $b Non-identique TRUE si $a n’est pas identique à $b.

Les opérateurs
Opérateurs de tableaux 2/2:
 L’opérateur + retourne le tableau de gauche auquel sont ajoutés les éléments du
tableau de droite.
Pour les clés présentes dans les 2 tableaux, les éléments du tableau de gauche seront
utilisés alors que les éléments correspondants dans le tableau de droite seront ignorés.
 Les éléments d’un tableau sont égaux en terme de comparaison s’ils ont la même clé
et la même valeur.

Les opérateurs
Opérateur de type:
Cela se résume au mot clé instanceof.
Il retourne la classe d’un objet instancié.
<?php
class MaClasse {}
class PasMaClasse {}
$a = new MaClasse;
var_dump($a instanceof MaClasse); // bool TRUE
var_dump($a instanceof PasMaClasse); // bool FALSE
?>

Les opérateurs
Opérateurs d’affectation :
 $a += $b équivalence $a = $a + $b Addition
 $a -= $b équivalence $a = $a - $b Soustraction
 $a *= $b équivalence $a = $a * $b Multiplication
 $a /= $b équivalence $a = $a / $b Division
 $a %= $b équivalence $a = $a % $b Modulo
 $a **= $b équivalence $a = $a ** $b Exponentielle
 $a .= $b équivalence $a = $a . $b Concaténation
 $a &= $b équivalence $a = $a & $b Bitwise And
 $a |= $b équivalence $a = $a | $b Bitwise Or
 $a ˆ= $b équivalence $a = $a ˆ $b Bitwise Xor
 $a <<= $b équivalence $a = $a << $b Left shift
 $a >>= $b équivalence $a = $a >> $b Right shift

Les structures de contrôle
Une structure de contrôle l’ordre dans lequel les instructions sont
exécutées.
 if, else,elseif, switch
 while, do while, for, foreach,
 break, continue, return, goto
 include, require, include once, require once

If :
L’expression entre parenthèse est convertie en booléen.
Si l’expression vaut TRUE, PHP exécutera les instructions et les ignore si elle vaut FALSE.
<?php
$a = 42;
if ($a > 1) {
echo ’Plus que 1’;
}
?>

Else :
Fonctionne après un if et exécute les instructions correspondantes au cas où l’expression
du if est FALSE.
<?php
$a = 42;
if ($a > 1) {
} else {
echo ’Pas plus de 1’;
}
?>

Elseif / Else if :
Fonctionne après un if et exécute les instructions correspondantes au cas où l’expression
du if est FALSE et que l’expression du elseif est TRUE.
<?php
$a = 42;
if ($a > 1) {
} elseif ($a < 0) {
echo ’Moins que 0’;
} else {
echo ’Pas plus de 1 et pas moins de 0’;
}
?>

Switch :
Equivaut à une série de if portant sur la même expression.
<?php
$a = 42;
switch ($a) {
case 0:
echo ’La valeur est 0’;
break;
case 42:
echo ’La valeur est 42’;
break;
default:
echo ’La valeur n ’est pas 0 ou 42’;
}
?>

Switch :
L’instruction break n'est pas obligatoire:
<?php
$a = 42;
switch ($a) {
case 0:
case 42:
echo ’La valeur est 0 ou 42’;
break;
default:
echo ’La valeur n’est pas 0 ou 42’;
}
?>

While :
Les instructions contenues dans la boucle tant que l’expression reste à TRUE.
<?php
$a = 0;
while ($a < 42) {
echo $a++;
}
?>
Ce code affichera les valeurs de 0 à 41.

Do While :
Très proche de la boucle while. La différence se situe au moment de l’interprétation de
l’expression: à la fin de l’itération.
<?php
$a = 0;
do {
echo $a++;
} while ($a < 42);
?>

Do While :
Dans l’exemple suivant le code contenu dans la boucle sera exécuté une fois même si
l’expression est fausse.
<?php
$a = 0;
do {
echo $a++;
} while ($a == 42);
?>
Ce code affichera 0.

For :
Dans l’exemple suivant le code contenu dans la boucle sera exécuté une fois même si
l’expression est fausse.
<?php
for (expression1; expression2; expression3) {
// Instructions
}
?>
L’expression1 est toujours exécutée au début de la boucle
L’expression2 conditionne l’exécution de la boucle (le ”if”)
L’expression3 est exécutée après chaque itération

For :
<?php
for ($i = 0; $i < 42; $i++) {
echo $i;
}
?>

Foreach :
Cette boucle permet de parcourir le contenu d’un tableau ou d’un objet.
<?php
$a = array(42, ’souris’, ’goodbye’);
foreach($a as $key => $value) {
echo $key . ’ = ’ . $value;
}
?>
Chaque élément du tableau sera affiché, précédé de sa clé.

Foreach :
La valeur de l’élément courant du tableau est copiée dans $value. Une modification de
$value n’influe pas sur le contenu du tableau.
Pour modifier la valeur il est possible d’utiliser $a[$key] =’xxx’;
ou d’utiliser une référence: $key => &$value
La partie ” $key =>” est optionnelle.
Lorsque la boucle démarre le pointeur interne du tableau est remis à 0.
$value et $key sont conservés après l’exécution.

Break :
L’instruction break permet de sortir d’une structure for, foreach, while, do-while ou switch.
<?php
$a = array(’un’, ’deux’, ’trois’, ’stop’, ’quatre’);
foreach( $a as $val ) {
if ($val == ’stop’) {
break;
}
echo $val;
}
?>
Le boucle n’affichera ni stop, ni quatre.

Break :
Par défaut break ne fait sortir que d’un seul niveau de boucle. Il est possible de lui
adjoindre en argument le nombre de niveaux à interrompre.
<?php
for ($i = 0; $i < 10; $i++) {
break 2;
}
echo $val;
}
}
?>
La boucle for sera aussi interrompue.

Continue :
L’instruction continue permet de sauter une partie d’une itération dans un for, foreach,
while, do-while ou switch.
<?php
continue;
}
echo $val;
}
?>
Le boucle n’affichera pas stop, mais bien quatre.

Declare :
declare sert à ajouter des directives d’exécutions dans un bloc de code ou la suite d’un
script.
Deux utilisations sont possibles:
 ticks
 encoding

Declare : ticks
Il est possible de définir un handler qui s’exécutera tous les N ticks.
Un tick intervient à chaque ”commande” PHP.
Le fonctionnement se rapproche de celui des interruptions.

Declare : ticks
<?php
declare(ticks=1);
function tickHandler() {
echo ’Handler called’;
}
register_tick_function(’tickHandler’);
$a = 1;
if ($a > 0) {
$a = 42;
echo $a;
}
?>

Declare : ticks
Le code précédent est équivalent à :
<?php
function tickHandler() {
echo ’Handler called’;
}
$a = 1; // 1 tick
tickHandler();
if ($a > 0) {
$a = 42; // 1 tick
TickHandler();
echo $a; // 1 tick
tickHandler();
}
// 1 tick
tickHandler();
?>

Declare : encoding
L’encodage d’un script peut être spécifié encoding.
<?php
declare(encoding=’UTF-8’);
// le code
?>

Return :
Provoque un retour à l’appelant. Selon le contexte:
 depuis une fonction: retourne après l’appel
 depuis un fichier inclus: retourne après l’inclusion
 depuis le fichier principal: arrêt du script
Return n’est pas une fonction et son paramètre ne prend pas de parenthèses.

Include/Require :
Ces 2 instructions incluent et exécutent le fichier spécifié en argument.
Si l’inclusion échoue require déclenchera une erreur fatale, include ne déclenchera qu’un
warning.
Le contexte de l’inclusion sera appliqué au script inclus. Par exemple la fonction courante.

Include once/Require once :
Ces 2 instructions vérifient que le fichier n’a pas été inclu avant de réaliser l’inclusion.
Fichier vars.php
<?php
$couleur = ’verte’;
$fruit = ’pomme’;
?>
Fichier test.php
<?php
echo "Une $fruit $couleur"; // Une
include ’vars.php’;
echo "Une $fruit $couleur"; // Une pomme verte
?>

Goto :
Effectue un saut dans l’exécution du script vers un emplacement situé dans le même
contexte et fichier.
Si la cible du saut (le label) est situé en dehors d’une fonction alors le goto est interprété
comme un break.
Fichier vars.php
<?php
goto a;
echo ’Foo’;
a:
echo ’Bar’;
?>
Ce script affichera Bar.

Syntaxe alternative des structures de contrôle:
En PHP les blocs sont généralement regroupés par des accolades.
Cette syntaxe alternative remplace l’accolade ouvrante par un : (deux points) et l’accolade
fermante par endif; / endwhile; / endfor; / endforeach; ou endswitch;
<?php
$a = 42;
if ($a > 1):
elseif ($a < 0):
echo ’Moins que 0’;
else:
echo ’Pas plus de 1 et pas moins de 0’;
endif;
?>

Les fonctions
Une fonction est une sorte de ”sous programme” (une procédure)
prenant des arguments (ou paramètres) et retournant un résultat.
Elle est par conséquent une expression.
Une fonction peut être:
 intégrée : fournie par PHP ou une de ses extensions.
 utilisateur: permettant ainsi d’étendre les fonctionnalités natives.
Le nommage des fonction suit les mêmes règles que celui des variables et constantes.

Les fonctions
La déclaration d’une fonction se fait suivant cette syntaxe:
<?php
function monAddition ($argument1, $argument2) {
return $argument1 + $argument2;
}
echo monAddition( 4, 2); // Affiche 6
?>

Les fonctions
Une fonction n’a pas besoin d’être définie avant son utilisation.
Il n’y a pas non plus de fichiers ”.h”.
Une exception à cette règle:
si la fonction est définie dans une structure conditionnelle (if, else...) alors son utilisation
ne pourra avoir lieu qu’a posteriori.

Les fonctions
Les arguments peuvent prendre une valeur par défaut. Ils deviennent alors optionnels.
<?php
function monAddition ($argument1, $argument2 = 42) {
return $argument1 + $argument2;
}
echo monAddition(4); // Affiche 46
?>

Les fonctions
Depuis PHP 5.6 il est possible de définir un nombre d’arguments variables.
<?php
function monAddition (...$arguments) {
$sum = 0;
foreach($arguments as $value) {
$sum += $value;
}
return $sum;
}
echo monAddition( 1, 2, 3, 4); // Affiche 10
?>

Les fonctions
La valeur de retour d’une fonction est définie par l’instruction return.
Cette instruction est optionnelle.
Dans le cas où elle est omise la valeur de retour est NULL.
<?php
function monAddition () {
array_sum( func_get_args() );
}
echo monAddition( 1, 2, 3, 4); // N’affiche rien
?>

Les fonctions
L’appel à une fonction peut être fait depuis une variable.
<?php
function monAddition ($a, $b) {
return $a + $b;
}
$func = ’monAddition’;
echo $func( 1, 2); // Affiche 3
?>

Les fonctions
Une fonction est anonyme (closures) lorsqu’elle ne porte pas de nom.
Ce type de fonction est souvent utilisé comme fonction de callback ou assigné à une
variable.
<?php
$monAddition = function ($a, $b) {
return $a + $b;
}
echo $monAddition( 1, 2);
// Affiche 3
?>

PHP Advanced
Plan
 Programmation objet
 Gestion des erreurs
 Debugger
 Bases de données
 Sécurité
 Optimisations
 Design pattern
 Framework

PHP Objet
 Les classes : syntaxe de base
 Propriétés et constantes de classe
 Visibilité
 Héritage
 Classes abstraites et interfaces
 L’opérateur de résolution de portée
 Constructeurs et destructeurs
 Les méthodes magiques
 Comparaison

Introduction
Source Wikipedia
La programmation orientée objet (POO), ou programmation par objet, est un
paradigme de programmation informatique élaboré par les Norvégiens Ole-
Johan Dahl et Kristen Nygaard au début des années 1960 et poursuivi par les
travaux d’Alan Kay dans les années 1970.
Il consiste en la définition et l’interaction de briques logicielles appelées objets ;
un objet représente un concept, une idée ou toute entité du monde physique,
comme une voiture, une personne ou encore une page d’un livre. Il possède une
structure interne et un comportement, et il sait interagir avec ses pairs.
Il s’agit donc de représenter ces objets et leurs relations ;
l’interaction entre les objets via leurs relations permet de concevoir et réaliser
les fonctionnalités attendues, de mieux résoudre le ou les problèmes.

Introduction
Depuis PHP 5, le modèle objet a été réécrit.
Contrairement à PHP 4 il dispose d’un modèle objet
complet et performant.
Cependant celui-ci évolue constamment:
http://www.php.net/manual/fr/language.oop5.changelog.php

Classes : Syntaxe de base
Une classe est définie par l’instruction class, suivie du nom de la classe et
une paire d’accolades contenant la définition des propriétés et des
méthodes.
Le nom de la classe doit respecter les mêmes règles de
nommage que les variables.
Les fonctions d’une classe sont nommées des méthodes. Les constantes
et variables d’une classe sont appelées ”propriétés” ou ”attributs”.

<?php
class SimpleClass
{
// declaration d’une propriete
public $var = ’une valeur par defaut’;
// declaration des methodes
public function displayVar() {
echo $this->var;
}
}
?>

La variable $this est une référence à l’objet courant.
Elle permet l’accès aux méthodes et variables de l’objet
courant.
Elle est disponible lorsqu’une méthode est appelée
depuis un contexte objet (lorsque la classe est
instanciée).

PHP Objet
 Syntaxe de base
 Visibilité
 Héritage
 L’opérateur de résolution de portée
 Comparaison
 Références et copies
 Clonage
 Namespaces

Classes
Propriétés et constantes
Les propriété sont définies en utilisant un des mots-clés
”public”, ”protected”, ou ”private”; suivis d’une déclaration classique de
variable.
Ce mot-clé défini leur visibilité, nous y reviendrons plus tard.
<?php
class SimpleClass
{
// declaration d’une propriete
public $a = ’une valeur par defaut’;
// cette propriete sera NULL
private $b;
}
?>

Classes
Propriétés et constantes
Les constantes sont définies en utilisant le mot-clé
”const”, suivi d’une déclaration classique.
<?php
class SimpleClass
{
// declaration d’une constante
const MACONSTANTE = ’une valeur constante’;
}
?>

Visibilité
La visibilité d’une propriété ou d’une méthode est établie selon le mot-
clé préfixant sa déclaration:
 public : peut être appellé depuis n’importe où
 protected : les appels sont limités à la classe, ses parentes et ses
héritières
 private : les appels sont limités à la classe courante
Avant PHP 5 le mot-clé ”var” était utilisé. Il est aujourd’hui déprécié, son
comportement est équivalent à celui de ”public”.

Visibilité
Exemple de visibilité de propriété:
<?php
class SimpleClass
{
protected $protected = ’Hello’;
function printHello()
{
echo $this->protected;
}
}

Visibilité
Exemple de visibilité de méthode :
<?php
class SimpleClass
{
private function printHello()
{
echo ’Hello’;
}
public function printWorld()
{
echo ’World’;
}
}
$obj = new SimpleClass();
$obj->printHello(); // Erreur fatale
$obj->printWorld(); // Correct (accessible publiquement)

Héritage
L’héritage est la base des relations entre les différentes classes
dans la POO.
Lorsqu’une classe hérite (étend) d’une autre elle hérite de ses
propriétés et méthodes.
Son principal avantage est de pouvoir définir des classes
proposants les propriétés et méthodes communes à plusieurs
classes filles.
L’implémentation la plus courante repose sur le mot-clé ”extends”.
Il n’est pas possible d’hériter de plusieurs classes. Ce type de
besoin peut être adressé par l’utilisation des ”Traits”.

Héritage
Exemple d’héritage:
<?php
class SimpleClassA {
function printHello() {
echo ’Hello’;
}
}
class SimpleClassB extends SimpleClassA {
}
$obj = new SimpleClassB();
$obj->printHello(); // Affiche Hello
?>

Héritage
Exemple d’héritage:
<?php
echo ’Hello’;
}
}
echo ’World’;
}
}
$obj->printHello(); // Affiche World
?>

Héritage
Le mot-clé ”final” empêche les classes filles de surcharger
une méthode ou une classe.
Celui-ci précède alors le mot-clé de visibilité.
En résumé: une classe définie comme finale ne pourra pas
être étendue.

Héritage
Exemple d’utilisation de ”final”:
<?php
final public function printHello() {
echo ’Hello’;
}
}
echo ’World’;
}
}
?>
L’erreur obtenue:
Fatal error: Cannot override final method
SimpleClassA::printHello()Plan

Classes abstraites
et interfaces
Les classes et méthodes peuvent être définies comme abstraites
en les précédant du mot-clé ”abstract”. Dés lors elles ne peuvent
pas être instanciées.
Les méthodes définies comme abstraites doivent obligatoirement
se trouver dans une classe abstraite. Elles déclarent uniquement la
signature de la méthode.
Autrement dit: elles ne contiennent pas de code.
Le principal objectif d’une classe abstraite est de servir de base à
d’autres classes.

Classes abstraites
et interfaces
L’utilisation d’une classe abstraite comme parent impose
plusieurs contraintes:
 Les méthodes marquées comme abstraites doivent forcément
être définies dans la classe fille.
 La visibilité ne peut pas être réduite.
Exemple: ce qui est défini ”protected” pourra devenir ”public”
mais pas ”private”.
 A partir de PHP 5.4: les types et le nombre des arguments
obligatoires doivent être les mêmes. Il est donc possible d’ajouter
des arguments optionnels.

Classes abstraites
et interfaces
<?php
abstract class SimpleAbstract {
protected $variable = ’Hello’;
public function printHello() {
echo $this->variable;
}
// Defini une methode a implementer
public function printWorld();
}
?>

Classes abstraites
et interfaces
<?php
class SimpleClass extends SimpleAbstract {
function printWorld() {
echo ’World’;
}
}
$obj = new SimpleClass();
$obj->printHello(); // Affiche Hello
$obj->printWorld(); // affiche World
?>

Classes abstraites
et interfaces
Une interface (en POO) spécifie ce que doit implémenter une classe fille.
Dans le principe une interface est proche d’une classe abstraite. La principale
différence se situe dans sa définition par le mot-clé ”interface”.
Une interface ne doit (et ne peut) pas contenir de code ni de variable.
Elle peut par contre contenir ses propres constantes.
Toutes les méthodes d’une interface doivent être publiques.
Une interface peut hériter d’autres interfaces grâce au mot-clé ”extends”.
A l’opposé, une classe utilisera le mot-clé ”implements” pour utiliser une
interface.

Classes abstraites
et interfaces
<?php
// Le mot-cle "class" est absent
// Il est remplace par "interface"
interface SimpleInterface {
public function printHello();
public function printWorld();
}
?>

PHP Objet
 Syntaxe de base
 Visibilité
 Héritage
 Opérateur de résolution de portée
 Comparaison
 Clonage
 Namespaces

Opérateur de résolution de
portée
L’opérateur de résolution de portée est représenté par le
symbole ”::” (double deux-points).
Il permet d’accéder aux membres static ou constant, ainsi qu’aux
propriétés ou méthodes surchargées d’une classe.
Il est précédé du nom de la classe ou des mots clés ”self”,
”parent”, ”static”.

portée
<?php
echo ’Hello’;
}
}
parent::printHello();
echo ’World’;
}
}
$obj->printHello(); // Affiche Hello World
?>

portée
Les mots-clés spéciaux:
 parent : fait référence à la classe parente.
 self : fait référence à la classe dans laquelle le code est
défini.
 static : fait référence à la classe active durant
l’exécution
La différence de comportement entre ”self” et ”static” est le
résultat du ”late static binding”.
http://www.php.net/manual/fr/language.oop5.late-static-bindings.php

portée
Une méthode peut être appellée sans instancier la classe à condition qu’elle
soit déclarée comme ”static”.
<?php
static function printHello() {
echo ’Hello’;
}
}
SimpleClassA::printHello(); // Affiche Hello
?>
Attention, il n’est pas possible d’utiliser $this dans une méthode static.

portée
Différence de comportement entre ”self” et ”static” :
class A {
public static function get_self() {
return new self();
}
public static function get_static() {
return new static();
}
}
class B extends A {}
echo get_class(B::get_self()); // A
echo get_class(B::get_static()); // B
echo get_class(A::get_static()); // A

Constructeurs et destructeurs
Le constructeur et le destructeur d’une classe sont appellés
automatiquement lors de l’instanciation d’un objet ou la
destruction de ce dernier.
Il est possible de déclarer une méthode qui sera exécutée lors
de ces évènements.
Celle-ci doit être nommée :
 __construct() : il s’agit du constructeur.
 __destruct() : il s’agit du destructeur.

Constructeurs et destructeurs
<?php
function __construct() {
echo ’Hello’;
}
function __destruct() {
echo ’World’;
}
}
$obj = new SimpleClassA(); // Affiche Hello
unset($obj); // Affiche World
?>

PHP Objet
 Syntaxe de base
 Visibilité
 Héritage
 Opérateur de résolution de portée
 Méthodes magiques
 Comparaison
 Clonage
 Namespaces

Les méthodes magiques
Le constructeur et le destructeur sont des méthodes magiques.
Il existe d’autres méthodes de ce type:
 __call() et __callStatic(): à chaque appel d’une méthode.
 __get(), __set(), __isset(), __unset() : lors d’opération sur des propriétés
 __sleep(), __wakeup() : lorsqu’un objet est passé aux méthodes
serialize() et unserialize().
 __toString() : lorsqu’un objet est interprété comme chaîne.
 __invoke() : lorsqu’un objet est interprété comme une fonction.
 __set state() : lorsqu’un objet est passé à la méthode var export().
 __clone() : lorsqu’un objet est cloné.

Comparaison
Lors d’une comparaison (==) deux objets sont identiques
s’ils sont des instances de la même classe et ont les
mêmes propriétés et valeurs.
Lors d’une comparaison d’identité (===) deux objets sont
identiques s’ils font références à la même instance.

Références et copies
La variable représentant un objet n’est qu’une référence vers l’instance.
Par conséquent la copie de cette variable ne duplique pas
l’objet et ne fait qu’un alias vers le même contenu.
Une ”vraie copie” se nomme clonage. Elle se réalise grâce au mot-clé
”clone” que nous détaillerons par la suite.

Références et copies
<?php
public $value = 42;
}
$objA = new SimpleClassA();
$objB = $objA;
$objB->value = 0;
echo $objA->value; // Affiche 0
?>
Dans cet exemple $objA et $objB sont des références vers le même
objet.

Clonage
Lors du clonage d’un objet PHP effectue une copie
superficielle de toutes les propriétés de l’objet.
Ainsi les propriétés qui sont des références pointeront
vers les mêmes contenus.
Le clonage se réalise grâce au mot-clé ”clone”.
Le comportement peut être personnalisé grâce à la
méthode __clone().

Clonage
<?php
public $value = 42;
}
$objA = new SimpleClassA();
$objB = clone $objA;
$objB->value = 0;
echo $objA->value; // Affiche 42
?>
Dans cet exemple $objA et $objB sont des références vers 2 objets.

Namespaces
Un namespace (ou espace de nom) est un moyen
d’encapsuler des éléments.
Leur but est de permettre de créer un élément ayant peut
être le même nom qu’un autre sans pour autant risque de
collision de noms.
Ils peuvent contenir:
 des classes
 des fonctions
 des constantes

Namespaces
Définition d’un namespace:
<?php
namespace MaSocieteMonProjet;
const MACONSTANTE = ’Hello’;
class SimpleClass { }
function simpleFunction() { }
?>
La définition d’un namespace doit intervenir au tout début du script. Il
n’est pas possible d’inclure du HTML ou du code PHP avant cette
déclaration.
Seule exception: la commande ”declare” précisant un encodage de
fichier.

Namespaces
Dans l’exemple précédent le code est contenu dans le namespace
MaSocieteMonProjet.
Il est possible de définir plusieurs namespaces dans un même
fichier.
Dans ce cas, et bien que non obligatoire, il est recommandé
d’englober l’ensemble du code de chaque namespace dans des
accolades.

Namespaces
Utilisation des éléments d’un namespace:
<?php
// appel non qualifie: le namespace courant est ajoute
simpleFunction();
// Devient MaSocieteMonProjetsimpleFunction()
// appel relatif: le namespace courant est ajoute
SousEspacesimpleFunction();
// Devient MaSocieteMonProjetSousEspacesimpleFuncti
// appel absolu
MaSocieteMonProjetsimpleFunction();
?>

Namespaces
Importation de namespaces:
Afin de faciliter l’utilisation d’autres namespaces il est possible
d’importer ceux-ci avec le mot-clé ”use”.
<?php
use AutreSocieteLeurProjet;
use AutreSocieteLeurAutreProjet as LAP;
use function AutreSocieteUnProjetuneFonction as xFunc
// Ces appels deviennent possibles
LeurProjetuneFonction();
LAPuneFonction();
xFunc();
?>

Namespaces
Utilisation du namespace global:
Si on souhaite accéder à un élément natif de PHP alors qu’un
élément du même nom existe il sera nécessaire de le préfixer
d’un (antislash).
<?php
function strlen($str) {
// Mon code
}
// Appel a la fonction du namespace
strlen(’Hello’);
// Appel a la fonction native
strlen(’Hello’);
?>

PHP Advanced
Plan
 Debugger
 Données et Bases de données
 Sécurité
 Optimisations
 Design pattern
 Framework

Gestion des erreurs
 Erreurs pour les fonctions PHP internes
 Exceptions pour les objets
 Possibilité de définir ses propres exceptions en
étendant la classe Exception

Gestion des erreurs
Les exceptions
Les exceptions permettent de gérer des erreurs:
 intercepter des erreurs fin de les gérer ”proprement”
 définir nos propres types d’erreurs
Le fonctionnement est très proche de celui rencontré dans d’autres
langages.

Gestion des erreurs
Les exceptions
Exemple d’exception: http://www.php.net/manual/fr/language.exceptions.php
<?php
function inverse($x) {
if (!$x) { throw new Exception(’Division par 0.’); }
return 1/$x;
}
try {
echo inverse(5) . "n";
echo inverse(0) . "n";
} catch (Exception $e) {
echo ’Exception recue : ’, $e->getMessage(), "n";
} finally {
echo "Echo depuis finaly.n";
}
echo "Bonjour le monde !n";
?>

Gestion des erreurs
Les exceptions
Le résultat obtenu:
0.2
Exception reçue : Division par zéro.
Echo depuis finaly.
Bonjour le monde !
Le code situé dans le bloc ”finaly” est toujours exécuté à la suite du try ou du catch (≥ PHP
5.5).
L’exception lancée est interceptée par le ”catch” qui affiche le message d’information.
L’exécution du script reprend après le bloc d’exception.

Gestion des erreurs
Les exceptions
Il est possible de lever manuellement une exception.
Cela se fait avec l'instruction : throw
function maFonction($param = null){
if( !isset($param) ){
throw new Exception("param est vide");
}
}
try{
maFonction();
} catch(Exception $e){
print_r($e);
}

Gestion des erreurs
Les exceptions
Depuis PHP 5.3 il est possible de définir ses propres types d’exceptions.
Certaines règles sont à respecter:
 La nouvelle exception doit être une classe fille de la classe « Exceptions » (voir
PHP Objet).
 Les exceptions ne peuvent pas être clônées (voir PHP Objet).
Plus d’informations: http://www.php.net/manual/fr/language.exceptions.extending.php

Gestion des erreurs
Logger les erreurs
Logger
 error_log : fonction PHP
 En développant ou utilisant des classes de logger (exemple Monolog)
Différentier les logs
 En affinant le niveau de log (développement / production)
 En loggant des fichiers différents selon le niveau de criticité

Debugger
De base
 Les erreurs PHP sont difficiles à lire.
 Les erreurs PHP ne sont pas des exceptions mais des erreurs fatales
 Impossibilité de voir la pile d'appel
Il est possible mettre en place des outils plus performants
 XDebug: Zend PHP extension - http://xdebug.org/docs/
 D'autres outils
 D'utiliser ces outils dans les environnements de programmation

Debugger - Xdebug
Configuration de xdebug (dans la configuration PHP)
zend extension=/path/to/your/install/xdebug.so
xdebug. default enable = 1
xdebug. collect params = 1
xdebug. collect return = 1

Debugger - Xdebug

Debugger – Xdebug / trace
xdebug. trace enable trigger = 1
xdebug. trace output dir = /path/to/writable/ folder
xdebug.trace output name = trace.%c
Appel à la demande via l'URL http://example.local/page.php?XDEBUG TRACE=1

Debugger – Xdebug / trace

Debugger – Xdebug Profiling
xdebug. profiler enable = 0
xdebug. profiler enable trigger = 1
xdebug. profiler output dir = /path/to/writable/ folder
xdebug. profiler output name = cachegrind.out.%t
Appel à la demande via l'URL http://example.local/page.php?XDEBUG PROFILE=1

Debugger – Xdebug Profiling

Debugger – Xdebug distant
xdebug. profiler enable = 0
xdebug. profiler enable trigger = 1
xdebug. profiler output dir = /path/to/writable/ folder
xdebug. profiler output name = cachegrind.out.%t
xdebug.remote enable = 1
xdebug.remote autostart = 0
xdebug.remote host = localhost
xdebug.remote port = 9000
Et configuration de l'IDE

Données (GET et POST)
Les données envoyées par un formulaire peuvent être lues
depuis ces variables:
 $_GET
 $_POST
 $_REQUEST

Exemple
Fichier Form.html
<form action="action.php" method="post">
<p>Votre nom: <input type="text" name="nom" /></p>
<p>Votre ville: <input type="text" name="ville" /></p>
<p><input type="submit" value="OK"></p>
</form>
Fichier action.php
Bonjour, <?php echo htmlspecialchars($_POST[’nom’]);?> .
Tu habites a <?php echo $_POST[’ville’];?>

Notes:
 action=”post” place la donnée dans $_POST pour le php
 action=”get” place la donnée dans $_GET pour le php
 Les variables passées en GET et POST sont aussi
accessibles dans le $_REQUEST

Attention à la sécurité !
Dans notre exemple le paramètre ville est affiché ”tel quel”
dans le rendu HTML.
On dit qu’il n’est pas ”échappé”. Si une personne mal
intentionnée envoie du HTML ou du Javascript à la place de sa
ville alors celui-ci est lu comme s’il faisait partie de la source
de la page.
La fonction ”htmlspecialchars()” nous protège en remplaçant
les caractères spéciaux du HTML.

Base de données
Un système de gestion de base de données (SGBD) est un
logiciel stockant les informations généralement de manière
structurée et classée.
Par rapport à un fichier texte les avantages sont nombreux:
 accéder rapidement aux données, autant en lecture
qu’en écriture
 partager des données entre plusieurs utilisateurs et
applications
 garantir l’intégrité et la pérennité des données

Base de données
Quelques SGBD connues:
 MySQL d’Oracle (précédemment Sun et MySQL AB)
 Oracle DB d’Oracle
 DB2 d’IBM
 SQL Server de Microsoft
 PostgreSQL de Michael Stonebraker
 MariaDB de Monty Program AB
La liste pourrait être bien plus longue !

Base de données
Les données y sont agencées sous forme de tables contenant
des colonnes.
 Chaque table est un type d’enregistrements: les clients,
des produits, des livres...
 Chaque colonne correspond à une propriété d’un
enregistrement: l’adresse, le nom, le prix...
 Chaque ligne correspond à un enregistrement: le client
X, le produit 42...

Base de données
PHP peut se connecter à un grand nombre de SGBD.
Pour cela il dispose de connecteurs :
 certains sont destinées à un unique système de SGBD
 certains peuvent se connecter à de multiples SGBD
 certains SGBD disposent de plusieurs connecteurs

Base de données
SQL est l’acronyme de ”Structured Query Language”.
On pourrait le traduire en ”Langage de requête structurée”.
Il permet de communiquer avec une SGBD SQL afin de lui
donner des ordres:
 ajouter des données dans un emplacement de stockage
 obtenir des données correspondant à certains critères
 modifier des données correspondants à certains critères

Base de données
Chaque ordre est nommée une ”requête”.
En voici quelques exemples:
 SELECT age FROM customer WHERE id = 42
 INSERT INTO customer (name, age) VALUES (’Marvin’,
42)
 UPDATE customer set age = 43 WHERE name = ’Marvin’

Base de données
Dans la suite de nos exemples nous utiliserons la SGBD MySQL
et le connecteur PDO de PHP.
 Car MySQL est une des SGBD les plus répandue dans le
monde PHP.
 Car PDO est une méthode fiable et moderne d’accéder
aux SGBD.
Nous utiliserons la base d’exemple ”World DB” de MySQL. Celle-ci peut
être téléchargée ici: http://downloads.mysql.com/docs/world.sql.gz

Base de données
L’établissement d’une connexion au serveur de SGBD se fait
lors de l’instanciation de l’objet PDO:
<?php
$dsn = ’mysql:host=localhost;dbname=world’;
$user = ’root’;
$pass = ’secretpass’;
$dbh = new PDO($dsn, $user, $pass);
?>
La variable $dbh contient notre instance PDO et la connexion
qui lui est associée.

Base de données
PDO propose plusieurs méthodes afin d’envoyer mais aussi de
construire nos requêtes.
<?php
$user = ’root’;
$query = $dbh->query(’SELECT * from City’);
print_r($query);
?>

Base de données
Lorsqu’une requête contient des paramètres il est indispensable de
d’assurer qu’ils ne seront pas interprétés comme une partie de la
requêtes mais bien comme une valeur.
<?php
$user = ’root’;
$query = $dbh->query(’SELECT * from City WHERE Name='' .
$_GET['ville'] . ''');
$results = $query->fetchAll();
print_r($results);
?>

Base de données
Afin de se protéger PDO permet l’utilisation de requêtes préparées:
<?php
$user = ’root’;
$query = $dbh->prepare(’SELECT * from City WHERE Name=:cityname');
$query->bindParam(':cityname',$_GET['ville']);
$query->execute();
$results = $query->fetchAll();
print_r($results);
?>
PDO se charge du remplacement et de l’échappement des paramètres.

Base de données - jointure
Afin de sélectionner des données dans plusieurs tables il faut l'indiquer au SGBD en
indiquant les tables à joindre et les informations qui sont communes (afin d'établir une
relation entre les données).
Dans notre code PHP seule la requête sera modifiée
SELECT * FROM City WHERE Name=:cityname
devient
SELECT *
FROM City
JOIN Department ON City.department_id = Department.id
WHERE Name=:cityname
L'information commune permettant de faire la relation entre la ville et son département
est l'identifiant du département (department_id et id)
Conditions de la jointure : ON City.department_id = Department.id

Il est possible d'utiliser des alias afin de faciliter la lecture de la requête.
Vous pouvez choisir les alias de manière arbitraire mais il ne doit y avoir
qu'un alias et un seul par table.
SELECT *
FROM City c
JOIN Department d ON c.department_id = d.id
WHERE Name=:cityname
Cas particulier : Si vous établissez une relation d'une table vers elle-même vous
aurez un alias pour chaque utilisation de la table

Les types de jointures :
 INNER (jointure interne) : il doit y avoir des données de part et d'autre de la
jointure (on ne retourne que les lignes pour lesquelles c.department_id et d.id
correspondent)
 LEFT JOIN (jointure externe) : renvoie toutes les lignes de la première table y
compris celles pour lesquelles il n'y a pas de correspondance dans la 2eme (villes
sans département)
 RIGHT JOIN (jointure externe) : c'est l'inverse
Notez
 LEFT OUTER / RIGHT OUTER
 USING et NATURAL au lieu de ON si les 2 colonnes ont le même nom
 Jointure sans JOIN (déconseillé) : géré dans le WHERE

Base de données -
Transactions
Les transactions permettent d'appliquer une série de requêtes en
bloc et de faire en sorte que le bloc soit appliqué en une seule fois.
Il est également possible d'annuler l'intégralité des requêtes d'un
bloc en cas d'erreur au sein du bloc.

Base de données -
Transactions
<?php
try
{
$pdo->beginTransaction();
$pdo->query('SELECT * FROM City WHERE cityname = 'Paris'');
$pdo->query('INSERT INTO City SET cityname = 'Paris', data = 'test'');
$pdo->query('UPDATE City SET number = 3000');
$pdo->commit(); // si OK, valider la transaction
echo 'Tout s'est bien passé.'; // message
}
catch(Exception $e) //en cas d'erreur
{
$pdo->rollback(); //on annule la transation
echo 'Tout ne s'est pas bien passé, voir les erreurs ci-dessous<br />';
echo 'Erreur : '.$e->getMessage().'<br />';
exit(); //on arrête l'exécution s'il y a du code après
}

Les sessions
Les sessions permettent de sauver des données entre 2 appels
de scripts.
Fonctionnement:
 Lors de son premier appel de page le visiteur se voit
assigner un identifiant unique
 Celui-ci est stocké dans un cookie.
 Les données attachées à la session sont
automatiquement stockées et chargées d’appels en
appels.

Les sessions
Exemple de fonctionnement:
<?php
// Initialise la session
session_start();
if (!isset($_SESSION[’count’])) {
$_SESSION[’count’] = 0;
echo ’Premier appel’;
} else {
echo $_SESSION[’count’]++;
}
?>
Si on efface le cookie de session ou en changeant de navigateur le
compteur repart à 0.

PHP Advanced
Plan
 Debugger
 Données et bases de données
 Sécurité
 Optimisations
 Design pattern
 Framework

PHP Advanced
Sécurité
 Données utilisateur
 Sécuriser les données
 Gestion des accès

Sécurité
Données Utilisateur
Vous ne pouvez pas faire confiance aux données provenant de
l'extérieur (notamment de l'utilisateur).
Vous devez vérifier qu'elles sont conformes à ce que vous
attendez et les sécuriser.

Sécurité
Injection SQL
Image by xkcd : http://xkcd.com/327/

Sécurité
Injection SQL
Vous ne pouvez pas faire confiance aux données provenant de
l'extérieur (notamment de l'utilisateur).
Vous devez vérifier qu'elles sont conformes à ce que vous
attendez et les sécuriser.
Vous devez échapper les données ou mieux utiliser des
mécanismes automatiques d'échappement des données (voir
requêtes préparées en PDO)

Sécurité
Injection SQL

Sécurité
Injection SQL
Requêtes préparées et paramétrées
$query = $dbh->prepare(’INSERT INTO REGISTRY (name, value) VALUES (?, ?)');
$query->bindParam(1, $_POST['ville']);
$query->bindParam(2, $_POST['population']);
$query->execute();
$query = $dbh->prepare(’INSERT INTO REG (name, value) VALUES (:name,:val)');
$query->bindParam(':name', $_POST['ville']);
$query->bindParam(':val', $_POST['population']);
$query->execute();

Sécurité
Faille include ou upload
 La fonction include est utilisé pour exécuter du code PHP se
situant sur une autre page.
 Attention à son utilisation :
●
include($_GET['fichier']); peut être une instruction
dangereuse.

Sécurité
XSS : Cross Site Scripting
C'est la possibilité d'injecter du code HTML ou Javascript dans des
variables.
Lors de l'affichage de ces données le code injecté permet d'être
exécuté depuis le serveur du pirate en utilisant le contexte de votre
page et de votre serveur web.
L'objectif est de récupérer, de modifier la page (modification du
DOM), de l'amener à effectuer des opérations illégitimes voire à
voler des informations personnelles (cookies par exemple).

Sécurité
XSS
$string = "<p>I’m a bad guy <script>doEvil();alert(’HAHA’);</script></p>";
$string = strip_tags($string);
// I’m a bad guy doEvil();alert(’HAHA’);
$string = strip_tags($string, ’<p>’);
// <p>I’m a bad guy doEvil();alert(’HAHA’);</p>
$string = htmlspecialchars($string);
// <p>I’m a bad guy <script>doEvil();alert(’HAHA’);</script></p>

Sécurité
XSS : Cross Site Scripting – contre mesures
 Vérifiez que les données sont conformes à ce que vous
attendez
 Échappez les données avant de les utiliser
 Attention cela peut affecter les éléments HTML, les attributs
HTML, les scripts (JS notamment) et même le CSS
 N'utilisez JAMAIS des données brutes

Sécurité
Sécuriser les données
 Protégez les accès :
– Restreindre les accès au serveur (admin sys)
– Restreindre les droits de l'utilisateur de base de données
 Crypter les données sensibles
 Ne pas stocker de données non nécessaires

Sécurité
Gestion des accès
 Authentification sécurisée :
– Encrypter les mots de passe
– Utiliser des cookies de session cryptés
 Vérifier les autorisations et droits sur CHAQUE action
 Protection contre les attaque CSRF
– GET seulement pour la consultation
– Utilisez des tokens de validation dans les formulaires
– Validez le REFERER
– Ajoutez une validation pour les actions critiques

Optimisations
Où une application web peut-elle être ralentie ?

Optimisations
A peu près partout !

Optimisation
Identifer un goulet d'étranglement : précautions
 Rester ouvert d'esprit, le goulet n'est pas toujours où on le
pense
 Appliquer les efforts sur le problème principal en premier
(effet max)
 Faites confiance à vos outils et aux faits (plus qu'à votre
intuition)
 Mesurez les améliorations (nécessite d'avoir un point initial)

Optimisation
Identifer un goulet d'étranglement : Outils
 Trousse d'urgence :
– Profilers intégrés (dans les frameworks)
– Firebug
– Analyse dichotomique
 Mesure Front-end :
– Yslow
– Analyse en ligne
 Mesures Back-end
– Xdebug
– Xhprof

Optimisation
Optimisations Front-end courantes
 Configurez le serveur web pour réutiliser les connexions et
compresser les données
 Compressez et combinez les fichiers statiques (js / CSS / img -
sprites)
 Limitez les données par page (ergonomie)
 Limitez le nombre d'appels ajax par pae
 Limitez les ressources externes (publicités, analytics), en
différer l'appel ou passer par des frames

Optimisation
Optimisations Back-end courantes : Bases de données
 Analysez les slow queries pour ajuster les index
 Ne ramenez que ce qui est nécessaire (sélection et conditions
- SELECT myfield WHERE mycondition = 'crit')
 Ramenez l'ensemble de ce dont vous avez besoin en utilisant
les jointures (pour diminuer le nombre de requêtes)
 Parfois séparer une requête en plusieurs plus petites peut
aider

Optimisation
Optimisations Back-end courantes : réseau
 Les services externes peuvent être instables, lents ou tomber en panne.
Votre application ne doit pas dépendre d'eux
 Vous devez avoir une solution de rechange (et l'utiliser) :
– quand le service externe est trop lent (et le logger)
– quand le service externe retourne une erreur (et le logger)
 Utilisez une tâche planifiée pour ramener les données régulièrement
 Utilisez vos données propres si possible

Optimisation
Optimisations Back-end courantes : cache
 Le cache est efficace lorsque le stockage est plus rapide que
la récupération ou le calcul
 Ne pas mettre en cache des données volatiles ou spécifiques
 Deux stratégies (peuvent être mixées) :
– Time To Live : une date d'expiration est ajoutée au moment de la
mise en cache
– Application-driven : l'expiration du cache est piloté par l'application
(typiquement sur lors de la mise à jour de la donnée ou du contenu)

Design patterns
 Conceptions de code réutilisables
 Exemples
– Post-redirect-get : multi soumission de requêtes POST
– Strategy : design pattern comportemental grâce auquel des
algorithmes peuvent être sélectionnés à la volée au cours du
temps d'exécution selon certaines conditions.

Design patterns
MVC : Modèle Vue Contrôleur
Le pattern MVC permet d'organiser son code. Le but est de séparer la logique
du code en trois parties distinctes :
– Modèle : Logique métier et accès aux données
– Vue : Interractions avec l'utilisateur, présentation.
– Contrôleur : Gère la dynamique de l'application, la logique du code qui
prend les décisions.

Design patterns
MVC : Modèle Vue Contrôleur

Design patterns : MVC
Le principe de conception logicielle prône la responsabilité unique. Afin qu'un
projet soit viable à long terme, il faut répondre à un ensemble de problématiques
de bases.
La solution MVC permet de répondre à quelques-unes de ses problématiques :
- Problématique de présentation : saisie et contrôle de données, affichage.
- Problématique de traitements : opérations sur les données en rapport avec les
règles métier.
- Problématique des données : Accès et stockage des informations.

Exemple d'une page en flat PHP.
Soit une page Web qui affiche une liste de jeux contenus dans une base de
donnée mysql, sur laquelle nous allons intéragir avec l'extension PDO de PHP.

<!doctype html>
<html lang="fr">
<head>
<meta charset="UTF-8" />
<link rel="stylesheet" href="style.css" />
<title>Liste de jeux</title>
</head>
<body>
<div id="global">
<header>
<a href="index.php"><h1 id="titreBlog">Liste de jeux</h1></a>
<p>Les meilleurs jeux vidéos PC de l'année</p>
</header>
<div id="contenu">
<?php
$bdd = new PDO('mysql:host=localhost;dbname=gamelist;charset=utf8',
'root', '');
$games = $bdd->query('select GAME_ID as id, GAME_DATE as date,'
. ' GAME_TITLE as title, GAME_DESC as description from T_GAME, '
. ' GAME_RATE as rate from T_GAME order by GAME_RATE desc');
foreach ($games as $game): ?>
<article>
<header>
<h1 class="titreBillet">
<?php echo $game['rate'] ?> - <?php echo $game['title'] ?>
</h1>
<time><? php echo $game['date'] ?></time>
</header>
<p><? php echo $game['desc'] ?></p>
</article>
<hr />
<?php endforeach; ?>
</div> 
<footer id="piedBlog"> Site réalisé avec PHP, HTML5 et CSS.</footer>
</div> 
</body>
</html>
Index.php

Plusieurs problèmatiques apparaissent avec ce type de page :
●
On mélange du code HTML et PHP.
●
Tout est dans un même bloc, nous allons donc devoir dupliquer le code si
jamais nous souhaitons créer une nouvelle page.
●
L'évolution et la maintenance du site deviendra de plus en plus complexe au
fil du temps.

Amélioration de l'exemple
Le principe est de séparer dans un premier temps le code d'accès aux
données du code de présentation.
Nous allons donc créer 2 nouveaux fichiers :
●
Models/games/model.php
●
Templates/games/list.php

Models/games/model.php
<?php
// Renvoie la liste de tous les jeux, triés par notes
décroissantes
function getGames() {
$bdd = new PDO('mysql:host=localhost;dbname=gamelist;charset=utf8', 'root', '');
$games = $bdd->query('select GAME_ID as id, GAME_DATE as date,'
. ' GAME_TITLE as title, GAME_DESC as description, '
. ' GAME_RATE as rate from T_GAME '
. ' order by GAME_RATE desc');
return $games;
}
?>

<!doctype html>
<html lang="fr">
<head>
...
</head>
<body>
...
<div id="contenu">
<?php foreach ($games as $game): ?>
<article>
...
</article>
<hr />
...
</body>
</html>

Il manque maintenant à faire le lien entre notre vue et notre modèle.
Le contrôleur va remplir ce rôle, pour cela nous allons modifier notre fichier
index.php
<?php
require 'Models/games/model.php';
$games = getGames();
require 'Templates/games/list.php';

Nous sommes maintenant sur une architecture MVC, bien que très simpliste.
Le modèle peut encore être largement amélioré.

Models/Game.php<?php
require_once 'Models/Model.php';
class Game extends Model {
// Renvoie la liste des billets du blog
public function getGames() {
$sql = 'select GAME_ID as id, GAME_DATE as date,'
. ' GAME_TITLE as title, GAME_DESC as description, '
. ' order by GAME_RATE desc';
$games = $this->executerRequete($sql);
return $games;
}
// Renvoie les informations sur un billet
public function getGame($idGame) {
$sql = 'select GAME_ID as id, GAME_DATE as date,'
. ' GAME_TITLE as title, GAME_DESC as description,'
. ' where GAME_ID=?';
$game = $this->executerRequete($sql, array($idGame));
if ($game->rowCount() == 1)
return $game->fetch(); // Accès à la première ligne de résultat
else
throw new Exception("Aucun jeux ne correspond à l'identifiant '$idGame'");
}
}

Models/Model.php
<?php
abstract class Model {
// Objet PDO d'accès à la BD
private $bdd;
// Exécute une requête SQL éventuellement paramétrée
protected function executerRequete($sql, $params = null) {
if ($params == null) {
$resultat = $this->getBdd()->query($sql); // exécution directe
}
else {
$resultat = $this->getBdd()->prepare($sql); // requête préparée
$resultat->execute($params);
}
return $resultat;
}
// Renvoie un objet de connexion à la BD en initialisant la connexion au besoin
private function getBdd() {
if ($this->bdd == null) {
// Création de la connexion
$this->bdd = new PDO('mysql:host=localhost;dbname=gamelist;charset=utf8',
'root', '', array(PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION));
}
return $this->bdd;
}
}

Nous pouvons séparer la vue de nos jeux et créer un gabarit (layout)
comprenant le corps HTML (head, header, footer …).
Nous n'aurions alors plus qu'a inclure la vue de nos jeux dans notre gabarit.

<?php ob_start(); ?>
<?php foreach ($games
as $game): ?>
<article>
…
</article>
<?php $contenu =
ob_get_clean(); ?>
<?php require
'/Templates/gabarit.ph
p'; ?>
<!doctype html>
<html lang="fr">
<head>
<meta charset="UTF-8" />
<link rel="stylesheet" href="Contenu/style.css" />
<title><?= $titre ?></title>
</head>
<body>
<div id="global">
<header>
<a href="index.php"><h1 id="titreBlog">Liste de Jeux</h1></a>
<p>Les meilleurs jeux vidéos PC de l'année</p>
</header>
<div id="contenu">
<?= $contenu ?>
<footer id="piedBlog">
Sité réalisé avec PHP, HTML5 et CSS.
</footer>
</div> 
</body>
</html>
Templates/gabarit.php

Au fur et à mesure de cette optimisation, nous apercevons des limites de
notre « framework » maison.
Par exemple, l'appel des fonctions PHP ob_start / ob_get_clean qui peuvent
se dupliquer, des fonctions require sans protection d'une éventuelle absence
du fichier etc …
Créer une architecture robuste est très intéressant et fortement formatrice,
mais le nombre de problématiques sera exponentiel au fur et à mesure de
l'avancement.
Dans un contexte de production, il sera donc plus interessant d'utiliser un
framework php solide.

Frameworks
De nombreux framework existent, soit un ensemble de composants logiciels
qui permettrons d'avoir les fondations de nos sites webs.
Un framework intègre tout un plan d'architecture et de nombreux patterns.
Ils permettent de commencer avec un « squelette » solide et de ne pas « ré-
inventer la roue ».

Frameworks
Les avantages sont nombreux :
– Des standards qui facilitent le travail en groupe et la maintenance.
– Une meilleure sécurité
– Une large communauté
– Partager les développements entre différents projets
– ...

Frameworks
Exemple de framework : Symfony
●
V1 : Créée en Octobre 2005 par Fabien Potencier et François Zaninotto
●
V2 : Première version stable en 2011 avec plus de 800 contributeurs

Frameworks
Symfony 2
●
PHP ≥ 5.3.3
●
Github
●
Doctrine 2
●
PHPUnit
●
Twig template engine
●
Actuellement en version 3
●
Standards PSR-1 et PSR-2

Frameworks
Symfony 2
●
Vocabulaire :
●
"Bundle" : Un bundle est en quelques sorte un module ou une fonctionnalité. Le coeur de symfony2 lui même est
développé à partir d'un ensemble de bundles.
●
"Doctrine" : C'est la librairie de gestion de base de données.
●
"Fixture" : Ce sont des bouts de scripts que l'on peut lancer en mode commande et qui vont générer un ensemble
de données de départ dans la base de données.
●
"Twig" : Comme doctrine, twig est une librairie qui n'est pas propre à symfony, il s'agit là d'un système de template
pour les applications PHP. Il existe 3 possiblités en symfony de créer nos vues : En PHP, en XML ou en TWIG.

Frameworks
Symfony 2
●
Structure d'un projet par défault :
●
App/
– AppKernet.php
– autoload.php
– console
– config/
– Resources/
– logs/
– cache/
●
src/
– YourNamespace/YourBundle
●
vendor/
●
web/

Frameworks
Symfony 2
●
Structure d'un projet par défault :
– / : Le dossier principal que vous avez créé, contenant tout votre projet symfony
– Le dossier "app" : C'est ici que se passera tout ce qui touche à la configuration de l'application, les identifiants de la base
de données, le référencement des différents bundles, la configuration de la sécurité ou encore le routage des différentes
urls à traiter.
– Le dossier "src" : C'est l'emplacement qui va nous intéresser le plus, il contiendra, l'ensemble des controlleur, des vues
ainsi que les modèles propres à notre application
– Le dossier "vendor" : Ce dossier contiendra tous les bundle fournis avec symfony qui permettent de personnaliser votre
framework selon vos besoins
– Enfin le dossier "web" contiendra tous les fichiers qui doivent être accessibles publiquement comme par exemple les
images, les fichiers css. Mais aussi et surtout, les points d'entrée de toutes les requêtes utilisateurs.

Frameworks
Symfony 2
Pour reprendre notre exemple :
●
Télécharger Symfony et lancer la commande d'installation pour configurer
son projet
●
Générer notre bundle : GameBundle
– Choisir entre autre le format, généralement en yml ou annotation
php app/console generate:bundle --namespace=Ens/GameBundle –format=yml
●
Créer notre objet Game. Définir ça structure dans :
– src/Ens/GamesBundle/Resources/config/doctrine/Game.orm.yml

Frameworks
Symfony 2
●
Générer les classes pour notre objet :
– php app/console doctrine:generate:entities EnsGameBundle
●
On peux voir dans le répertoire Entity notre classe dans Game.php :
– src/Ens/GameBundle/Entity/Game.php
●
Manque plus qu'à créer notre table en BDD
– php app/console doctrine:schema:update
●
Il faudra alors remplir quelques datas tests en BDD (manuellement ou alors
en utilisant DoctrineFixturesBundle)

Frameworks
Symfony 2
●
Notre modèle est créé, il ne reste plus qu'à gérer la vue et configurer le
contrôleur.
●
Pour la vue, on garde le même principe, soit créer un layout global et créer
nos blocs avec twig. Reste alors à créer notre block de contenu et d'étendre
notre layout global.
●
Le contrôleur va permettre de faire le lien entre notre modèle et notre
template selon la demande de l'utilisateur.
●
Nous allons ici, simplement modifier l'action afin de sélectionner toutes les
données de notre entité et de d'envoyer les bons paramètres à la vue.

Frameworks
Symfony 2
●
Attention de bien configurer le routing.
●
Et nous aurons accès à la liste des jeux sur navigateur !

PHP & Initiation Symfony

Contenu connexe

Tendances (19)

Similaire à PHP & Initiation Symfony (20)

Plus de Open Source School (11)

PHP & Initiation Symfony