2. Classes et libraires PhP

2.1 Utilisation de librairies et d'API

Une librairie est un programme permettant d'effectuer un certain nombre d'opérations. Autrement dit, une boite à outils que vous pouvez utiliser dans vos programmes (au lieu de tout programmer vous-même). Une librairie a une API.
Un API (Application Programmer's Interface) est une liste de fonctions (ou procédures ou méthodes) et de variables (ou classes) documentées et que vous pouvez utiliser.

N'utilisez pas d'autres fonctions/variables que vous repérées dans le code, car elle risquent de ne plus marcher avec la prochaine mise à jour de la librairie.

A. Inclusion de librairies

Normalement la documentation vous dit comment utiliser une librairie. Dans la doc de ADOdb (voir page 22) par exemple, on trouve le texte suivant:

When running ADOdb, at least two files are loaded. First is adodb/adodb.inc.php, which contains all functions used by all database classes.

include('/path/to/set/here/adodb.inc.php');

Cela veut dire que pour utiliser adodb, il faut d'abord télécharger et installer la librairie quelque part et ensuite la "charger" dans votre fichier PhP avec la fonction PhP "include". Voici un exemple:

$adodb_path = "/web/lib/php/adodb";

include("$adodb_path/adodb.inc.php");

Note: On peut aussi installer des libraires "dans le système" et dans ce cas il aurait suffit de la chercher avec un simple include("adodb/adodb.inc.php");

La fonction include (par défaut) charge un fichier depuis n'importe quel répertoire accessible à PHP, donc il faut indiquer un chemin relatif ou absolu du système !
Variantes de la fonction include () :

include_once() - évite d'inclure plus qu'une fois le même fichier lors d'une éxécution, variante souvent utilisée dans des systèmes larges (portails, etc.)
require() - arrête l'exécution de votre programme s'il y a erreur
require_once()

2.3 Un premier regard sur les objets en PhP 4

Ici nous présentons un simple exemple (voir les explications 2 pages plus loin)
Pour une classe "Students" nous définissons le "cahier des charges" suivant:

Elle définit un objet "étudiant" avec 2 propriétés: son nom ( $name ) et une liste d'une longueur aléatoire de notes ( $scores )
On peut demander à un objet le nom de l'étudiant (fonction accesseur)
On peut ajouter des notes une par une avec une autre méthode
On peut demander à l'objet la note globale, c.a.d. de calculer la moyenne des notes.

Exemple 2-1: Une simple classe PHP

http://tecfa.unige.ch/guides/php/examples/simple-objects/class-object.php

class
 Student {

// propriétés de la classe

  var $name;

  var $scores;

// fonction "constructeur" pour créer l'objet (voir explication plus loin)

 function Student ($nom) { $this->name = $nom; }

// Fonction accesseur pour le nom de l'étudiant

 function getName () { return $this->name; }

// fonction accesseur pour les notes (sans tester s'il en a !)

  function getGrade () {

    $sum = 0;

    $n_scores = sizeof($this->scores);

    foreach ($this->scores as $score) {

      $sum += $score;

    $grade = $sum / $n_scores;

    return $grade;

// accessor function pour insérer une note

  function addScore ($score) { $this->scores[] = $score; }

// end of Student class definition

Utilisation de la classe student:

// Création de 2 étudiants:

$nath = new Student("Nathalie Dupont");

$jule = new Student
("Gilles Jules");

// Ajouter quelques notes à Nathalie:

$nath->addScore(4); $nath->addScore(5); $nath->addScore(3); 
$nath->addScore(6);

// Imprimer sa moyenne:

echo "Grade obtained by ".$nath->getName()
. ": " .$nath->getGrade()
;

2.4 Définition de la classe

Toutes les définitions de propriétés (variables de la classe) et de méthodes (fonctions de la classe) sont faites à l'intérieur des { ... } [en tout cas on le conseille]

class
 Student{

....

Pour créer un objet, aussi appelé instance on utilisera le mot clé "new" et un constructeur (voir E. "Constructeurs" [11])

new Student();

Pour ne pas le "perdre" on peut le mettre dans une variable

$etudiant = new Student ();

A. Définition de propriétés (variables d'objets)

On définit les propriétés (variables de la classe) avec le mot clé "var"
Le nom de la variable commence par un $ suivi d'au moins une lettre

class Student{

  var $propriete_XXX;

  var $propriete_YYY

2.5 Définition de méthodes qui accèdent à une propriété

On accède à une propriété d'un objet avec la construction $object_x->variable_xxx

La variable "$object_x" contient donc un objet

"$this" veut dire qu'on demande à un objet de se référer à lui-même
Voici un exemple simple qui retourne la valeur de la propriété "name":

function getName () {

  return
 $this->name
;

Exemple d'utilisation:

$etudiant->getName();

Note: Il serait aussi possible d'accéder directement au nom avec $etudiant->name , mais ce type d'usage est fortement déconseillé, car il vaut mieux laisser une classe gérer sa méthode de stockage ! C'est le principe d'encapsulation, c.a.d le programmeur- utilisateur d'une classe devrait utiliser strictement les fonctions décrites dans l'API.

A. Définition de méthodes qui modifient une propriété

Même principe que ci-dessus pour modifier une propriété
Voici une simple méthode qui met à jour une propriété

function changeXXX ($valeur
) {

  $this->propriete_XXX = $valeur

B. Constructeurs

Un constructeur est une méthode qui crée une instance (objet) d'une classe. Cette méthode aura obligatoirement le même nom que la classe.

Note: En PHP on ne peut pas définir plusieurs constructeurs ayant des arguments différents (mais voir valeurs par défaut ci-dessous).

Le constructeur suivant crée un objet "student" et définit son nom

function Student ($nom) {

  $this->name = $nom;

Exemple d'utilisation:

$etudiant = new Student ("David Taylor");

Le constructeur suivant crée un objet "student" avec une valeur par défault

function Student ($nom="Anonymous") {

  $this->name = $nom;

Exemple d'utilisation:

$etudiant = new Student ;  // un constructeur sans parenthèses utilise

                         // les valeurs par défaut !

C. Méthodes "ordinaires"

Au-delà de ces exemples simples on utilisera les méthodes comme des fonctions "normales" avec la seule différence qu'on appelle toujours une méthode par le biais d'un objet.
Au concepteur de décider lesquelles feront partie de l'API.

dans les "vraies langages" de programmation on peut définir des méthodes publiques et privés, mais pas en PhP 4.

Voici une fonction qui calcule un score

(mais attention si l'étudiant n'a pas de scores, il va avoir une division / zéro et donc une erreur).

  function getGrade () {

    $sum = 0;

    $n_scores = sizeof($this->scores);

    foreach ($this->scores as $score) {

      $sum += $score;

    $grade = $sum / $n_scores;

    return $grade;

Exemple d'utilisation:

$etudiant->getGrade()
;

2.6 Utilisation d'une classe I

Exemple 2-2: Une simple classe PHP avec un include

http://tecfa.unige.ch/guides/php/examples/simple-objects/student-class.phps
http://tecfa.unige.ch/guides/php/examples/simple-objects/student-objects.php
http://tecfa.unige.ch/guides/php/examples/simple-objects/
Cet exemple contient plus ou moins le même code.

Toutefois la classe est définie dans un fichier à part (student-class.php). Il s'agit de la même classe.
Elle est utilisé dans student-objects.php, fichier qui contient une 2ème couche d'abstraction, c.a.d. des fonctions pour utiliser la classe "students".

Voici des extraits de code du fichier student-objets.php

// inclusion de la classe

include ("student-class.php");

// On définit un array pour stocker les étudiants

$students=array();

// une fonction pour entrer des notes

function addScore ($id, $grade) {

  global $students;

  $students[$id]->addScore($grade);

// une fonction pour afficher tous les résultats

function displayScores () {

  global $students;

  echo "<ol>";

  foreach ($students as $student) {

    echo "<li>Grade obtained by " . $student->getName() . ": " 
         . $student->getGrade() . "</li>";    }

  echo "</ol>";

// Un constructeur pour créer des étudiants

function makeStudent ($id, $name) {

  global $students;

  $students[$id]  = new Student($id, $name);

// On crée des étudiants, ils sont mis dans le array indexé $students

makeStudent("nath", "Nathalie Dupont");

makeStudent("jules, "Gilles Jules");

makeStudent("steph", "Stephane Durand");

// on ajoute des notes ...

addScore("nath",4); addScore("nath",5); addScore("nath",3);

addScore("jules",2); addScore("jules",1); addScore("jules",3);

....

// Afficher les résultats

 displayScores ();

2.7 Utilisation d'une classe II

Dans l'exemple précédant on avait une classe ("students") et quelques fonctions qui facilitent son usage (dans le fichier student-objects.php).
Au fond, on peut aussi créer une classe pour gérer tous les étudiants qui suivent un cours, autrement dit inclure dans une nouvelle classe ces fonctions.

Exemple 2-3: Deux simples classes PHP

http://tecfa.unige.ch/guides/php/examples/simple-objects/course-class.phps
http://tecfa.unige.ch/guides/php/examples/simple-objects/course-objects.php
http://tecfa.unige.ch/guides/php/examples/simple-objects/
La classe "Course" contient les méthodes publiques suivantes qu'un utilisateur pourra utiliser: Course() , makeStudent(), addScore(), et displayScores()
Dans ce cas précis l'utilisateur n'est plus censé utiliser les fonctions de la classe "Students" qu'on a également repris dans le code.

$staf14 = new Course("Staf14 ..... ");

$staf14->makeStudent("nath", "Nathalie Morand");

$staf14->addScore("nath",4); $staf14->addScore("nath",5);

$staf14->addScores("jules",array(2,1,3,5));

$staf14->displayScores (); // Print the results

Cet exemple montre bien qu'on peut avec une librairie simplifier la vie pour un programmeur d'application et donc pour un étudiant staf-14 ;)

2. Classes et libraires PhP

2.1 Utilisation de librairies et d'API

A. Inclusion de librairies

2.2 La programmation orientée objet

Définitions simplifiées (!!):

2.3 Un premier regard sur les objets en PhP 4

Exemple 2-1: Une simple classe PHP

Utilisation de la classe student:

2.4 Définition de la classe

A. Définition de propriétés (variables d'objets)

2.5 Définition de méthodes qui accèdent à une propriété

A. Définition de méthodes qui modifient une propriété

B. Constructeurs

C. Méthodes "ordinaires"

Exemple d'utilisation:

2.6 Utilisation d'une classe I

Exemple 2-2: Une simple classe PHP avec un include

Voici des extraits de code du fichier student-objets.php

2.7 Utilisation d'une classe II

Exemple 2-3: Deux simples classes PHP