<< Retour au sommaire

 

 

PHP, La programmation orientée objets

 

 

 

Le sommaire :

  1. Démarrage.
  2. Première classe.
  3. Une méthode.
  4. Avec 2 méthodes maintenant.
  5. Le constructeur.
  6. Un tableau comme instance de classe.
  7. Plaçons la classe dans un fichier « inc » externe !
  8. Un petit jeu ?
  9. Un exemple avec l’affichage de la date du jour.
  10. L’héritage :

10.1  Introduction,

10.2  Héritage de l’attribut et du constructeur,

10.3  Héritage des méthodes,

  1. Un opérateur d’appel de méthodes, la surcharge.
  2. La portée d’un objet, la linéarisation :

12.1  Présentation,

12.2  Un exemple de linéarisation par passage de paramètre,

12.3  Un exemple de linéarisation avec une variable de session.

 

 

Démarrage

 

Avant de partir à la découverte de la programmation orientée objets, vous devez impérativement apprendre et maîtriser les cours antérieurs à ce chapitre, et ce, afin de ne pas confondre les différents éléments que vous allez manipuler, j’insiste, vous devez avoir clairement compris l’utilité et la manipulation de variables et de fonctions.

 

Une «classe est un modèle qui contient des variables et des fonctions.

Mais attention, la classe étant considérée comme un modèle, comme un plan en quelle que sorte, vous ne pouvez pas utiliser les fonctions proposées par la classe en employant directement le nom de la classe.

Et oui, vous devez déclarer un objet basé sur le modèle de la classe.

Un objet est une variable de type « objet ».

 

C’est donc  ensuite à partir de cet objet, que vous pourrez profiter pleinement des fonctions décrites dans la classe.

 

Mais soyons désormais rigoureux concernant le vocabulaire employé dans la programmation orientée objets…

 

Le modèle est donc une « classe », la classe peut contenir des variables principales appelées « attributs », puis viennent les fonctions qui réalisent des opérations, ces fonctions peuvent bien sûr recevoir des données en paramètre !

 

Plus loin dans le code PHP, lorsque l’on déclare une « variable » de type « classe », en fait on crée un « objet ».

Cet objet sera basé sur le modèle de la classe.

Cette opération est dite « instanciation », et l’objet est dit « l’instance de classe ».

Les variables principales de la classe devenue variables de l’objet, seront les « attributs ».

Les fonctions de la classe quant à elles, deviennent les méthodes de l’objet.

 

Ouf !

 

Et si on illustrait dès maintenant ?


Première classe

 

Nous allons créer la classe « commande » qui contiendra l’attribut « $NomClient ».

Cette classe ne contiendra aucune fonction.

Puis, dans le bloc <body>, nous allons déclarer l’objet « $Client ».

Du coup, l’objet « $Client » aura à sa disposition l’attribut « $NomClient » dans lequel on affectera un nom que l’on fera ensuite afficher par l’intermédiaire de l’instruction « echo ».

 

Remarque :

Comme nous avons prévu aucune fonction dans l’écriture de la classe « commande », l’objet « $Client » ne disposera d’aucune méthode !

 

<html>

<head>

<title>Ma première classe</title>

<?php

// Déclaration de la classe commande

class commande {

// Déclaration de l'attribut $NomClient

var $NomClient; } ?>

</head>

<body>

<?php

// Déclaration de l'objet $Client basé sur la classe commande

// Cette déclaration est appelée une instanciation

// l’objet $Client va donc être une instance de classe

$Client = new commande();

// Affectation d'une valeur dans l'attribut $NomClient

$Client->NomClient="dupond";

// Affichage du contenu de l'attribut $NomClient

echo $Client->NomClient; ?>

</body>

</html>

 

Bon, pour l'écriture de la classe, vous avez compris...

<?php

class NomDeLaClasse

{ Contenu de la classe, attributs et fonctions } ?>

 

Le contenu de la classe est placé entre accolades.

 

Ensuite, pour l’instanciation, donc la déclaration de l'objet comme étant basé sur le modèle de la classe :

 

$NomObjet = new NomClasse();

 

Puis, pour s'adresser aux variables principales de l'objet, donc aux attributs :

 

$MonObjet->NomAttribut

L'objet et l'attribut sont séparés par un "tiret" et le signe "supérieur".

 

Maintenant voici une seconde illustration !

Vous allez comprendre de vous-mêmes…

Ici, toujours basé sur la classe « commande », nous allons créer deux objets, « $PremierClient » et « $SecondClient ».

 

<html>

<head>

<title>Ma première classe</title>

<?php

// Déclaration de la classe commande

class commande {

// Déclaration de l'attribut $NomClient

var $NomClient; } ?>

</head>

<body>

<?php

// Instanciation de l'objet $PremierClient basé sur la classe commande

$PremierClient = new commande();

// Instanciation de l'objet $SecondClient basé également sur la classe commande

$SecondClient = new commande();

// Affectation d'une valeur dans l'attribut $NomClient pour le premier objet

$PremierClient->NomClient="dupond";

// Affectation d'une valeur dans l'attribut $NomClient pour le second objet

$SecondClient->NomClient="Duran";

// Affichage du contenu de l'attribut $NomClient pour les 2 objets

echo $PremierClient->NomClient;

echo "<br />";

echo $SecondClient->NomClient; ?>

</body>

</html>

 

Le premier « echo » affichera « Dupont », le deuxième affichera « Duran ».

 

Nous pouvons donc créer plusieurs objets basés sur le même modèle de classe, puis, exploiter distinctement ces objets dans notre code PHP.

Chaque objet sera réellement autonome et indépendant des autres, il conservera ses propres valeurs affectées dans ses attributs Etc.

 


Une méthode

 

Maintenant nous allons créer une fonction dans la classe « commande ».

Cette fonction s’appellera « afficher » et elle affichera à l’écran le contenu de la variable qui lui sera passé en paramètre.

Pour l’objet « $Client », cette fonction est une méthode !

 

<html>

<head>

<title>Ma deuxième classe</title>

<?php

// Déclaration de la classe commande

class commande {

// écriture de la fonction afficher

function Afficher($NomClient) {

echo $NomClient; }} ?>

</head>

<body>

<?php

// Instanciation de l'objet $Client basé sur la classe commande

$Client = new commande();

// Exécution de la méthode afficher

$Client->Afficher("DURAN"); ?>

</body>

</html>

 

 


Avec 2 méthodes maintenant

 

<html>

<head>

<title>Les calculs</title>

<?php

// Déclaration et définition de la classe operations

class operations {

// Définition de la première fonction, additionne

function additionne($Valeur1, $Valeur2) {

$LaSomme = $Valeur1 + $Valeur2;

return $LaSomme; }

// Définition de la deuxième fonction, multiplie

function multiplie($Valeur1, $Valeur2) {

$LeProduit = $Valeur1 * $Valeur2;

return $LeProduit; }} ?>

</head>

<body>

<?php

// Instanciation

// Création de l'instance de classe $calcule

$calcule = new operations();

// maintenant on s'éclate !

$Resultat = $calcule->additionne(5,5)+$calcule->multiplie(3,2);

// Nous venons d'envoyer 5 et 5 à la méthode additionne

// qui a été additionnées au produit résultant de la méthode multiplie

// à qui nous avons envoyé les valeurs 3 et 2

// Normalement le echo va vous afficher 16

echo $Resultat; ?>

</body>

</html>

 


Le constructeur

 

Mais pour que vos attributs soient reconnus dans les fonctions de la classe, il faut créer un constructeur.

 

A titre d’exemple, le code que je vous présente ci-après ne fonctionne pas car l’attribut « $NomDuClient » n’est pas reconnu par la fonction « afficher » :

 

<html>

<head>

<title>ça déconne</title>

<?php

class commande {

var $NomDuClient;

function afficher() {

echo $NomDuClient; }} ?>

</head>

<body>

<?php

$NouveauClient = new commande();

$NouveauClient->afficher(); ?>

</body>

</html>

 

Et oui, pour que l’attribut « $NomDuClient » soit reconnu dans les fonctions de la classe « commande », il faut écrire un constructeur.

Un constructeur est une fonction qui a le même nom que la classe et qui permet, grâce au mot clé « this », d’associer l’attribut « $NomDuClient » à un paramètre passé à la classe « commande ».

 

Voici la syntaxe, cette fois ça va marcher…

 

<html>

<head>

<title>Le constructeur</title>

<?php

class commande {

var $NomDuClient;

function commande ($MonParametre) {

$this->NomDuClient = $MonParametre; }

function afficher() {

echo $this->NomDuClient; }} ?>

</head>

<body>

<?php

$NouveauClient = new commande("duran");

echo "<p>Bonjour</p>";

echo "<p>";

$NouveauClient->afficher(); ?>

</p>

</body>

</html>

 

Voilà, nous sommes obligés de créer une fonction qui porte le même nom que la classe, et dont son unique objectif est d’accueillir en paramètre l’attribut qui sera maintenant reconnu par les fonctions de la classe.

 


Un tableau comme instance de classe

 

Vous pouvez utiliser un tableau comme objet.

En reprenant l’exemple cité juste au-dessus, nous allons remplacer l’objet « $NouveauClient » par un tableau :

 

<html>

<head>

<title>Le constructeur</title>

<?php

class commande {

var $NomDuClient;

function commande ($MonParametre) {

$this->NomDuClient = $MonParametre; }

function afficher() {

echo $this->NomDuClient; }} ?>

</head>

<body>

<?php

$NouveauClient[1] = new commande("duran");

$NouveauClient[2] = new commande("dupont");

echo "<p>Bonjour</p>";

echo "<p>Le premier client est : <br />";

$NouveauClient[1]->afficher();

echo "<br />Le deuxième client est :<br />";

$NouveauClient[2]->afficher(); ?>

</p>

</body>

</html>

 


Plaçons la classe dans un fichier « inc » externe !

 

Nous allons continuer depuis le même exemple, mais cette fois, nous allons définir la classe dans un fichier externe, nous allons appeler ce fichier « classes.inc ».

Du coup, dans le fichier « index.php », avant de réaliser l’instanciation, nous allons devoir inclure « classes.inc » par l’intermédiaire de la fonction « include ».

 

Voici le code de « classes.inc » :

 

<?php

class commande {

var $NomDuClient;

function commande ($MonParametre) {

$this->NomDuClient = $MonParametre; }

function afficher() {

echo $this->NomDuClient; }} ?>

 

Voici le code de « index ;php » :

 

<?php include("classes.inc"); ?>

<html>

<head>

<title>Le constructeur</title>

</head>

<body>

<?php

$NouveauClient[1] = new commande("duran");

$NouveauClient[2] = new commande("dupont");

echo "<p>Bonjour</p>";

echo "<p>Le premier client est : <br />";

$NouveauClient[1]->afficher();

echo "<br />Le deuxième client est :<br />";

$NouveauClient[2]->afficher(); ?>

</p>

</body>

</html>

 


Un petit jeu ?

 

Télécharger le jeu >>

 

Nous allons créer un fichier « index.php » qui va ouvrir un formulaire et demander à l’utilisateur de saisir la barre de titre, le titre d’un paragraphe et le paragraphe lui-même d’une page à afficher.

Dès lors que l’utilisateur aura renseigné ces informations, il validera le bouton du formulaire et le fichier « Resultat.php » sera exécuté.

 

Ce fichier récupèrera les données saisies dans « index.php » par le biais de la méthode « post », il inclura le fichier externe « classe.inc » qui contient une classe intitulée « afficher ».

 

Ensuite, toujours dans « Resultat.php », un objet « MaPage » sera créé et exécutera la méthode « Go » en passant en paramètres les données saisies par l’utilisateur !

La méthode « Go », quant à elle, construira la page à afficher…

 

Voici le code de « classe.inc » :

 

<?php

class afficher {

function Go($BarreDeTitre,$TitreDeParagraphe,$LeParagraphe) {

echo "<head>";

echo "<title>$BarreDeTitre</title>";

echo "</head>";

echo "<body>";

echo "<h1>$TitreDeParagraphe</h1>";

echo "<p>$LeParagraphe</p>";

echo "</body>"; }} ?>

 

Voici le code de « index.php » :

 

<html>

<head>

<title>Personnalisation d'une page</title>

</head>

<body>

<p>Bonjour, ici vous devez personnaliser la page à afficher !<br />

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

<label for="BarreDeTitre">

Veuillez saisir le nom de la barre de titre :<br />

</label>

<input type="text" name="BarreDeTitre" id="BarreDeTitre" size=25 /><br />

<label for="TitreDeParagraphe">

Veuillez saisir le titre du paragraphe :<br />

</label>

<input type="text" name="TitreDeParagraphe" id="TitreDeParagraphe" size="40" /><br />

<label for="LeParagraphe">

Maintenant vous pouvez saisir le contenu du paragraphe...<br />

</label>

<textarea name="LeParagraphe" id="LeParagraphe" rows="5" cols="50"></textarea><br />

<input type="submit" value="Valider" />

</form></p>

</body>

</html>

 

Voici le code de « Resultat.php » :

 

<?php include("classe.inc"); ?>

<html>

<?php

extract($_POST,EXTR_OVERWRITE);

$MaPage = new afficher();

$MaPage->Go($BarreDeTitre,$TitreDeParagraphe,$LeParagraphe); ?>

</html>


Un exemple avec l’affichage de la date du jour

 

Je vous propose un exemple sympa et surtout relativement facile qui affichera sur 2 lignes :

Aujourd’hui nous sommes le :

Puis la page affichera la date du jour !

 

Nous allons créer une classe appelée « LaDateDuJour ».

Cette classe aura un attribut intitulé « $Message » et le message à afficher devra donc être passé en paramètre à la classe au moment de l’instanciation.

Par exemple, « Aujourd’hui nous sommes le « .

Puis, la classe contiendra une méthode qui affichera « $Message » et bien sûr, à la ligne suivante, la date du jour…

 

Voici le code :

 

<html>

<head>

title>Affichage de la date du jour</title>

<?php

// Déclaration de la classe « LaDateDuJour »

class LaDateDuJour {

var $Message;

function LaDateDuJour ($Parametre) {

$this->Message = $Parametre; }

function DateDuJour() {

echo $this->Message.'<br />';

echo date("j m Y").'<br />'; }} ?>

</head>

<body>

<p>Bonjour</p>

<p>

<?php

$Afficher = new LaDateDuJour("Aujourd'hui nous sommes le :");

$Afficher->DateDuJour(); ?>

</p>

</body>

</html>


L’héritage

 

Introduction

 

L’héritage est probablement l’une des grandes forces de la programmation orientée objets !

Qu’est-ce que l’héritage ?

En résumé, vous avez la possibilité de créer une class qui va hériter des attributs et fonctions d’une autre classe…

Attention cependant, nous allons introduire le milieu familial…

En effet, pour qu’une nouvelle classe puisse hériter du contenu d’une classe existante, il vous suffit de définir la seconde classe comme étant la fille de la première classe !

De plus, l’héritage sera mutuel.

 

Le mot clé qui permet de définir une classe comme étant la fille d’une autre classe est « extends ».

 

Classe NomDeLaClasseBébéLol extends NomDeLaClasseMaman

{ Blablabla ; }

 

Héritage de l’attribut et du constructeur

 

Voici un exemple dans lequel la classe « ClasseHeure » va devenir héritière de la classe « ClasseDate » :

<html>

<head>

title>Affichage de la date du jour</title>

<?php

class ClasseDate {

var $Message;

function ClasseDate ($Parametre) {

$this->Message = $Parametre; }

function DateDuJour() {

echo $this->Message.'<br />';

echo date("j m Y").'<br />'; } }

class ClasseHeure extends ClasseDate {

function HeureDuJour () {

echo $this->Message.'<br />';

 echo date("h:i"); }} ?>

</head>

<body>

<p>Bonjour</p>

<p>

<?php

$Afficher = new ClasseDate("Aujourd'hui nous sommes le :");

$Afficher->DateDuJour();

$AfficherAussi = new ClasseHeure ("Il est donc ");

$AfficherAussi->HeureDuJour();

echo '<br />';

$AfficherAussi->Message = "On se refait la date ?";

$AfficherAussi->DateDuJour(); ?>

</p>

</body>

</html>

 


L’héritage des méthodes

 

Lorsque vous définissez une classe fille, cette dernière n’hérite pas uniquement que des attributs et des constructeurs qui en découlent.

En effet, la classe fille hérite également des méthodes de la classe mère et inversement…

 

Dans l’exemple qui suit, la classe ClasseHeure est la fille de ClasseDate.

Du coup, en plus de l’attribut de la classe mère qui va être exploité, la classe fille va également employer une méthode de la classe mère.

 

Voici le code :

 

<html>

<head>

<title>Affichage de la date du jour</title>

<?php

// Définition de la classe mère ClasseDate

class ClasseDate {

// Déclaration de l'attribut Message

var $Message;

// Constructeur pour l'attribut Message

function ClasseDate ($Parametre) {

$this->Message = $Parametre; }

// Fonction DateDuJour de la classe mère

function DateDuJour() {

echo $this->Message.'<br />';

echo date("j m Y").'<br />'; } }

// Définition de la classe fille ClasseHeure

class ClasseHeure extends ClasseDate {

// Définition de la fonction HeureActuelle

function HeureActuelle () {

echo $this->Message.'<br />';

 echo date("h:i"); }} ?>

</head>

<body>

<p>Bonjour</p>

<p>

<?php

// Instanciation de l'objet $Afficher à la classe ClasseHeure

// en passant en argument un texte à l'attribut Message

$Afficher = new ClasseHeure("Aujourd'hui nous sommes le :");

// Affichage de la date du jour par le biais de la méthode DateDuJour qui a été héritée

$Afficher->DateDuJour();

// Changement de texte dans l'attribut Message

$Afficher->Message="Il est très exactement ";

// Affichage de l'heure par le biais de la méthode HeureActuelle

$Afficher->HeureActuelle (); ?>

</p>

</body>

</html>

 


Un opérateur d’appel de méthodes, la surcharge

 

Avec le double signes « deux points », nous pouvons appeler une méthode extérieure à l’intérieure d’une fonction d’une autre classe.

Ce principe est dit « surcharge ».

 

La syntaxe :

class MaClasse {

function MaFonction () {

// appel de la méthode "afficher" de la classe "client"

// La classe "client" étant définie ailleurs, plus haut dans le code

client::afficher ();

// Maintenant le code de la fonction en cours de développement

blablabla; }}

 

La description :

MaClasse est la classe en cours de définition.

MaFonction est la fonction en cours de définition.

client::afficher est l’appel d’une méthode définie dans la classe « client » avant la définition de la classe MaClasse.

 

Remarque :

-         La classe contenant la déclaration de la surcharge n’a pas besoin d’être fille de la classe contenant la méthode.

 

Un exemple :

 

Ici, la page index.php demande à l’utilisateur de saisir son nom et son âge.

Après la validation du formulaire, la page suite.php est ouverte.

Dans la page suite.php, on inclut la classe externe « bienvenue » située dans le fichier externe « classes.inc « .

Ensuite, on crée la classe « accueil » qui contient la définition de la fonction « dire ».

La fonction en question appelle la méthode « afficher » de la classe « bienvenue ».

Ensuite, elle traite l’âge du visiteur…

 

Dans cet exemple, la méthode intitulée « afficher » de la classe « bienvenue » est exécutée dans la fonction « dire » de la classe « accueil ».

Cette opération peut être possible grâce à l’opérateur d’appel de méthodes…

 

Télécharger l’exemple >>

 

Le code du fichier externe « classes.inc » :

 

<?php

// Fichier externe de définitions de classes

class bienvenue {

var $message;

function bienvenue ($message) {

$this->message = $message; }

function afficher () {

echo $this->message; }} ?>

 


Le code de l’index.php :

 

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" >

<head>

<meta http-equiv="Content-Language" content="fr">

<meta name="GENERATOR" content="Microsoft FrontPage 5.0">

<meta name="ProgId" content="FrontPage.Editor.Document">

<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">

<title>Identification</title>

</head>

<body>

<h1>Vous devez vous identifier !</h1>

<pre>

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

<label for="TonPrénom">

Quel est ton prénom ? </label>

<input type="text" id="TonPrénom" name="TonPrénom" />

 

<label for="TonAge">

Quel est ton âge ? </label>

<input type="text" id="TonAge" name="TonAge" />

 

<input type="submit" value="Valider" />

</form></pre>

</body>

</html>

 


Le code de la page suite.php :

 

<?php

// Inclusion du fichier externe des classes

include ("classes.inc");

// Définition d'une classe spécifique à cette page

class accueil extends bienvenue {

function dire ($age) {

// Récupération de la fonction "afficher" de la classe "bienvenue"

bienvenue::afficher();

echo "<br />";

// Traitement de l'âge du visiteur

if ($age<18) {

 echo "Mais tu es trop jeune pour naviguer sur ce site, tchao !"; }

else {

 echo "En plus, tu as l'âge requis pour visiter notre site ! Félicitation..."; }}} ?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" >

<head>

<meta http-equiv="Content-Language" content="fr">

<meta name="GENERATOR" content="Microsoft FrontPage 5.0">

<meta name="ProgId" content="FrontPage.Editor.Document">

<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">

<title>Page 2</title>

</head>

<body>

<h1>Ouverture du site</h1>

<p>

<?php

// Récupération des champs de formulaire de la page index.php

extract ($_POST,EXTR_OVERWRITE);

// Instanciation de l'objet $visiteur sur la classe accueil

$visiteur = new accueil ("Salut $TonPrénom ! Je connais ton âge ! Tu as $TonAge ans...");

// Exécution de la méthode "dire"

$visiteur->dire($TonAge); ?>

</p>

</body>

</html>

 


La portée d’un objet, la linéarisation

 

Présentation

 

Malheureusement, il est impossible de passer un objet en paramètre à la page que l’on souhaite ouvrir.

 

Alors, afin de pouvoir conserver les données qui ont été affectées dans les attributs d’un objet, et ce, durant le passage d’une page à une autre, il va vous falloir exploiter un aspect technique du PHP appelé « la linéarisation ».

 

La linéarisation est le fait de convertir la structure de l’objet et de ses données en une suite de données de type chaîne de caractères.

 

Avant de quitter la page qui contient l’objet, on affecte le contenu de l’objet dans une variable intermédiaire par le biais de la fonction « serialize ».

Ensuite, à l’exécution de l’ouverture de la nouvelle page, la variable intermédiaire est passée en paramètre.

Dans la nouvelle page, la variable intermédiaire est récupérée par le biais de la méthode « GET ».

Il reste ensuite à déclarer une nouvelle variable à qui l’on affecte le résultat de la délinéarisation de la variable intermédiaire, et ce, grâce à la fonction « unserialize ».

 

La syntaxe globale :

Pour linéariser un objet :

$VariableIntermédiaire = serialize ($MonObjet);

Puis, pour reconstruire un objet depuis la linéarisation :

 $NouvelObjet = unserialize ($VariableIntermédiaire);

 

Voilà, c’est tout !

C’est à vous maintenant de savoir gérer le passage de la variable intermédiaire par le biais de la méthode « GET » !

 

Remarque :

-         Vous pouvez également réaliser l’opération de linéarisation par le biais d’une variable de session…

 


Un exemple de linéarisation par passage de paramètre

 

Télécharger l’exemple >>

 

Dans l’exemple suivant, nous allons procéder à une linéarisation par le biais d’un passage de paramètre via la méthode « GET ».

 

Dans la page index.php, nous demandons à l’utilisateur de saisir son nom et son prénom, puis de cliquer le bouton « Valider ».

Le fichier script intitulé « FichierScript.php » est exécuté.

Ce fichier script récupère le formulaire par la méthode « POST ».

Ensuite, il inclut le fichier « classes.inc » qui contient la définition de la classe « NouveauVisiteur ».

Cette classe accepte 2 attributs en paramètres, le nom et le prénom, et propose la méthode « afficher », qui affiche le nom et le prénom du visiteur ainsi qu’un message de bienvenue.

Donc, toujours dans le fichier « FichierScript.php », l’objet $visiteur est instancié à la classe NouveauVisiteur en lui affectant le nom et le prénom.

Puis, cet objet est linéarisé par la fonction « serialize » dans la variable $passage qui et, à son tour, passée en paramètre à la page suite.php par le biais de la fonction « header ».

Dans la page suite.php, on inclut le fichier externe qui contient la définition de la classe « NouveauVisiteur ».

Ensuite, après la récupération du paramètre via la méthode « GET », on affecte la variable linéarisée « $passage » au nouvel objet « $visiteur » par la fonction « unserialize ».

 

Puis, dans le « body », il suffit d’exécuter la méthode « afficher » de l’objet « $visiteur »…

 


Le code du fichier externe de définitions de classes, « classes.inc :

 

<?php

// Fichier externe de définitions de classes

class NouveauVisiteur {

// Déclaration des 2 attributs de la classe

var $prénom;

var $nom;

// Élaboration du constructeur des 2 attributs

function NouveauVisiteur ($prénom,$nom) {

$this->prénom = $prénom;

$this->nom = $nom; }

// Définition de la fonction "afficher" avec l'affichage d'un message approprié et des 2 attributs

function afficher () {

 echo "Je te souhaite la bienvenue ";

 echo $this->prénom;

 echo " ";

 echo $this->nom; }} ?>

 


Le code de l’index :

 

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" >

<head>

<meta http-equiv="Content-Language" content="fr">

<meta name="GENERATOR" content="Microsoft FrontPage 5.0">

<meta name="ProgId" content="FrontPage.Editor.Document">

<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">

<title>Identification</title>

</head>

<body>

<h1>Vous devez vous identifier !</h1>

<pre>

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

<label for="TonPrénom">

Quel est ton prénom ? </label>

<input type="text" id="TonPrénom" name="TonPrénom" />

 

<label for="TonNom">

Quel est ton nom ? </label>

<input type="text" id="TonNom" name="TonNom" />

<input type="submit" value="Valider" />

</form></pre>

</body>

</html>

 


Le code du fichier script, « FichierScript.php » :

 

<?php

// Inclusion du fichier externe contenant la définition de la classe NouveauVisiteur

include ("classes.inc");

// Récupération du formulaire de la page index.php

extract ($_POST,EXTR_OVERWRITE);

// instanciation de l'objet $visiteur vers la classe NouveauVisiteur

// avec initialisation des 2 attributs

$visiteur = new NouveauVisiteur ($TonPrénom,$TonNom);

// linéarisation de l'objet $visiteur dans la variable $passage

$passage = serialize ($visiteur);

// Ouverture de la page suite.php en lui passant en paramètre le résultat de la linéarisation de l'objet $visiteur

header ("location:suite.php?passage=$passage"); ?>

 


Le code de la page suite.php :

 

<?php

// Inclusion du fichier externe des classes

include ("classes.inc");

// Récupération de la variable linéarisée

extract ($_GET,EXTR_OVERWRITE);

// Initialisation de l'objet $visiteur depuis la linéarisation

$visiteur = unserialize ($passage); ?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" >

<head>

<meta http-equiv="Content-Language" content="fr">

<meta name="GENERATOR" content="Microsoft FrontPage 5.0">

<meta name="ProgId" content="FrontPage.Editor.Document">

<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">

<title>Page 2</title>

</head>

<body>

<h1>Ouverture du site</h1>

<p>

<?php

// Exécution de la méthode "afficher"

$visiteur->afficher (); ?>

</p>

</body>

</html>

 


Un exemple de linéarisation avec une variable de session

 

Télécharger l’exemple >>

 

Ici, nous reprenons le même exemple que celui présenté au chapitre précédent.

Seulement, au lieu d’employer le passage de paramètre via la méthode « GET » pour sauvegarder l’objet, nous allons utiliser une variable de session !

 

Le code du fichier externe de définitions de classes, « classes.inc » :

 

<?php

// Fichier externe de définitions de classes

class NouveauVisiteur {

// Déclaration des 2 attributs de la classe

var $prénom;

var $nom;

// Élaboration du constructeur des 2 attributs

function NouveauVisiteur ($prénom,$nom) {

$this->prénom = $prénom;

$this->nom = $nom; }

// Définition de la fonction "afficher" avec l'affichage d'un message approprié et des 2 attributs

function afficher () {

 echo "Je te souhaite la bienvenue ";

 echo $this->prénom;

 echo " ";

 echo $this->nom; }} ?>

 


Le code de l’index :

 

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" >

<head>

<meta http-equiv="Content-Language" content="fr">

<meta name="GENERATOR" content="Microsoft FrontPage 5.0">

<meta name="ProgId" content="FrontPage.Editor.Document">

<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">

<title>Identification</title>

</head>

<body>

<h1>Vous devez vous identifier !</h1>

<pre>

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

<label for="TonPrénom">

Quel est ton prénom ? </label>

<input type="text" id="TonPrénom" name="TonPrénom" />

 

<label for="TonNom">

Quel est ton nom ? </label>

<input type="text" id="TonNom" name="TonNom" />

<input type="submit" value="Valider" />

</form></pre>

</body>

</html>

 


Le code du fichier script « FichierScript.php » :

 

<?php

// Déclaration de l'emploi de variables de session

SESSION_START ();

// Inclusion du fichier externe contenant la définition de la classe NouveauVisiteur

include ("classes.inc");

// Récupération du formulaire de la page index.php

extract ($_POST,EXTR_OVERWRITE);

// instanciation de l'objet $visiteur vers la classe NouveauVisiteur

// avec initialisation des 2 attributs

$visiteur = new NouveauVisiteur ($TonPrénom,$TonNom);

// linéarisation de l'objet $visiteur dans la variable de session $_SESSION("passage"]

$_SESSION["passage"] = serialize ($visiteur);

// Ouverture de la page suite.php

header ("location:suite.php"); ?>

 


Le code de la page suite.php :

 

<?php

// Déclaration de l'utilisation des variables de session

SESSION_START ();

// Inclusion du fichier externe des classes

include ("classes.inc");

// Initialisation de l'objet $visiteur depuis la linéarisation

$visiteur = unserialize ($_SESSION['passage']); ?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" >

<head>

<meta http-equiv="Content-Language" content="fr">

<meta name="GENERATOR" content="Microsoft FrontPage 5.0">

<meta name="ProgId" content="FrontPage.Editor.Document">

<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">

<title>Page 2</title>

</head>

<body>

<h1>Ouverture du site</h1>

<p>

<?php

// Exécution de la méthode "afficher"

$visiteur->afficher (); ?>

</p>

</body>

</html>

 

Philippe BOULANGER